<!DOCTYPE html>
<html lang="en" dir="ltr" class="client-nojs">
<head>
<title>Arithmetic operators - cppreference.com</title>
<meta charset="UTF-8">
<meta name="generator" content="MediaWiki 1.21.2">
<link rel="shortcut icon" href="../../../common/favicon.ico">
<link rel="stylesheet" href="../../../common/ext.css">
<meta name="ResourceLoaderDynamicStyles" content="">
<link rel="stylesheet" href="../../../common/site_modules.css">
<style>a:lang(ar),a:lang(ckb),a:lang(fa),a:lang(kk-arab),a:lang(mzn),a:lang(ps),a:lang(ur){text-decoration:none}#toc{display:none}.editsection{display:none}
/* cache key: mwiki1-mwiki_en_:resourceloader:filter:minify-css:7:472787eddcf4605d11de8c7ef047234f */</style>

<script src="../../../common/startup_scripts.js"></script>
<script>if(window.mw){
mw.config.set({"wgCanonicalNamespace":"","wgCanonicalSpecialPageName":false,"wgNamespaceNumber":0,"wgPageName":"cpp/language/operator_arithmetic","wgTitle":"cpp/language/operator arithmetic","wgCurRevisionId":141460,"wgArticleId":703,"wgIsArticle":true,"wgAction":"view","wgUserName":null,"wgUserGroups":["*"],"wgCategories":["Pages with unreviewed LWG DR marker"],"wgBreakFrames":false,"wgPageContentLanguage":"en","wgSeparatorTransformTable":["",""],"wgDigitTransformTable":["",""],"wgDefaultDateFormat":"dmy","wgMonthNames":["","January","February","March","April","May","June","July","August","September","October","November","December"],"wgMonthNamesShort":["","Jan","Feb","Mar","Apr","May","Jun","Jul","Aug","Sep","Oct","Nov","Dec"],"wgRelevantPageName":"cpp/language/operator_arithmetic","wgRestrictionEdit":[],"wgRestrictionMove":[]});
}</script><script>if(window.mw){
mw.loader.implement("user.options",function(){mw.user.options.set({"ccmeonemails":0,"cols":80,"date":"default","diffonly":0,"disablemail":0,"disablesuggest":0,"editfont":"default","editondblclick":0,"editsection":0,"editsectiononrightclick":0,"enotifminoredits":0,"enotifrevealaddr":0,"enotifusertalkpages":1,"enotifwatchlistpages":0,"extendwatchlist":0,"externaldiff":0,"externaleditor":0,"fancysig":0,"forceeditsummary":0,"gender":"unknown","hideminor":0,"hidepatrolled":0,"imagesize":2,"justify":0,"math":1,"minordefault":0,"newpageshidepatrolled":0,"nocache":0,"noconvertlink":0,"norollbackdiff":0,"numberheadings":0,"previewonfirst":0,"previewontop":1,"quickbar":5,"rcdays":7,"rclimit":50,"rememberpassword":0,"rows":25,"searchlimit":20,"showhiddencats":0,"showjumplinks":1,"shownumberswatching":1,"showtoc":0,"showtoolbar":1,"skin":"cppreference2","stubthreshold":0,"thumbsize":2,"underline":2,"uselivepreview":0,"usenewrc":0,"watchcreations":0,"watchdefault":0,"watchdeletion":0,
"watchlistdays":3,"watchlisthideanons":0,"watchlisthidebots":0,"watchlisthideliu":0,"watchlisthideminor":0,"watchlisthideown":0,"watchlisthidepatrolled":0,"watchmoves":0,"wllimit":250,"variant":"en","language":"en","searchNs0":true,"searchNs1":false,"searchNs2":false,"searchNs3":false,"searchNs4":false,"searchNs5":false,"searchNs6":false,"searchNs7":false,"searchNs8":false,"searchNs9":false,"searchNs10":false,"searchNs11":false,"searchNs12":false,"searchNs13":false,"searchNs14":false,"searchNs15":false,"gadget-ColiruCompiler":1,"gadget-MathJax":1});;},{},{});mw.loader.implement("user.tokens",function(){mw.user.tokens.set({"editToken":"+\\","patrolToken":false,"watchToken":false});;},{},{});
/* cache key: mwiki1-mwiki_en_:resourceloader:filter:minify-js:7:9f05c6caceb9bb1a482b6cebd4c5a330 */
}</script>
<script>if(window.mw){
mw.loader.load(["mediawiki.page.startup","mediawiki.legacy.wikibits","mediawiki.legacy.ajax"]);
}</script>
<style type="text/css">/*<![CDATA[*/
.source-cpp {line-height: normal;}
.source-cpp li, .source-cpp pre {
	line-height: normal; border: 0px none white;
}
/**
 * GeSHi Dynamically Generated Stylesheet
 * --------------------------------------
 * Dynamically generated stylesheet for cpp
 * CSS class: source-cpp, CSS id: 
 * GeSHi (C) 2004 - 2007 Nigel McNie, 2007 - 2008 Benny Baumann
 * (http://qbnz.com/highlighter/ and http://geshi.org/)
 * --------------------------------------
 */
.cpp.source-cpp .de1, .cpp.source-cpp .de2 {font: normal normal 1em/1.2em monospace; margin:0; padding:0; background:none; vertical-align:top;}
.cpp.source-cpp  {font-family:monospace;}
.cpp.source-cpp .imp {font-weight: bold; color: red;}
.cpp.source-cpp li, .cpp.source-cpp .li1 {font-weight: normal; vertical-align:top;}
.cpp.source-cpp .ln {width:1px;text-align:right;margin:0;padding:0 2px;vertical-align:top;}
.cpp.source-cpp .li2 {font-weight: bold; vertical-align:top;}
.cpp.source-cpp .kw1 {color: #0000dd;}
.cpp.source-cpp .kw2 {color: #0000ff;}
.cpp.source-cpp .kw3 {color: #0000dd;}
.cpp.source-cpp .kw4 {color: #0000ff;}
.cpp.source-cpp .co1 {color: #909090;}
.cpp.source-cpp .co2 {color: #339900;}
.cpp.source-cpp .coMULTI {color: #ff0000; font-style: italic;}
.cpp.source-cpp .es0 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es1 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es2 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es3 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es4 {color: #008000; font-weight: bold;}
.cpp.source-cpp .es5 {color: #008000; font-weight: bold;}
.cpp.source-cpp .br0 {color: #008000;}
.cpp.source-cpp .sy0 {color: #008000;}
.cpp.source-cpp .sy1 {color: #000080;}
.cpp.source-cpp .sy2 {color: #000040;}
.cpp.source-cpp .sy3 {color: #000040;}
.cpp.source-cpp .sy4 {color: #008080;}
.cpp.source-cpp .st0 {color: #008000;}
.cpp.source-cpp .nu0 {color: #000080;}
.cpp.source-cpp .nu6 {color: #000080;}
.cpp.source-cpp .nu8 {color: #000080;}
.cpp.source-cpp .nu12 {color: #000080;}
.cpp.source-cpp .nu16 {color:#000080;}
.cpp.source-cpp .nu17 {color:#000080;}
.cpp.source-cpp .nu18 {color:#000080;}
.cpp.source-cpp .nu19 {color:#000080;}
.cpp.source-cpp .ln-xtra, .cpp.source-cpp li.ln-xtra, .cpp.source-cpp div.ln-xtra {background-color: #ffc;}
.cpp.source-cpp span.xtra { display:block; }

/*]]>*/
</style><style type="text/css">/*<![CDATA[*/
.source-text {line-height: normal;}
.source-text li, .source-text pre {
	line-height: normal; border: 0px none white;
}
/**
 * GeSHi Dynamically Generated Stylesheet
 * --------------------------------------
 * Dynamically generated stylesheet for text
 * CSS class: source-text, CSS id: 
 * GeSHi (C) 2004 - 2007 Nigel McNie, 2007 - 2008 Benny Baumann
 * (http://qbnz.com/highlighter/ and http://geshi.org/)
 * --------------------------------------
 */
.text.source-text .de1, .text.source-text .de2 {font: normal normal 1em/1.2em monospace; margin:0; padding:0; background:none; vertical-align:top;}
.text.source-text  {font-family:monospace;}
.text.source-text .imp {font-weight: bold; color: red;}
.text.source-text li, .text.source-text .li1 {font-weight: normal; vertical-align:top;}
.text.source-text .ln {width:1px;text-align:right;margin:0;padding:0 2px;vertical-align:top;}
.text.source-text .li2 {font-weight: bold; vertical-align:top;}
.text.source-text .ln-xtra, .text.source-text li.ln-xtra, .text.source-text div.ln-xtra {background-color: #ffc;}
.text.source-text span.xtra { display:block; }

/*]]>*/
</style><!--[if lt IE 7]><style type="text/css">body{behavior:url("/mwiki/skins/cppreference2/csshover.min.htc")}</style><![endif]--></head>
<body class="mediawiki ltr sitedir-ltr ns-0 ns-subject page-cpp_language_operator_arithmetic skin-cppreference2 action-view cpp-navbar">
        <!-- header -->
        <!-- /header -->
        <!-- content -->
<div id="cpp-content-base">
            <div id="content">
                <a id="top"></a>
                <div id="mw-js-message" style="display:none;"></div>
                                <!-- firstHeading -->
<h1 id="firstHeading" class="firstHeading">Arithmetic operators</h1>
                <!-- /firstHeading -->
                <!-- bodyContent -->
                <div id="bodyContent">
                                        <!-- tagline -->
                    <div id="siteSub">From cppreference.com</div>
                    <!-- /tagline -->
                                        <!-- subtitle -->
                    <div id="contentSub"><span class="subpages">&lt; <a href="../../cpp.html" title="cpp">cpp</a>‎ | <a href="../language.html" title="cpp/language">language</a></span></div>
                    <!-- /subtitle -->
                                                            <!-- bodycontent -->
                    <div id="mw-content-text" lang="en" dir="ltr" class="mw-content-ltr"><div class="t-navbar" style=""><div class="t-navbar-sep"> </div><div class="t-navbar-head"><a href="../../cpp.html" title="cpp"> C++</a><div class="t-navbar-menu"><div><div><table class="t-nv-begin" cellpadding="0" style="line-height:1.1em;">
<tr class="t-nv"><td colspan="5"> <a href="../compiler_support.html" title="cpp/compiler support"> Compiler support</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../freestanding.html" title="cpp/freestanding"> Freestanding and hosted</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../language.html" title="cpp/language"> Language</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../header.html" title="cpp/header"> Standard library headers</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../named_req.html" title="cpp/named req"> Named requirements </a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../feature_test.html" title="cpp/feature test"> Feature test macros </a> <span class="t-mark-rev t-since-cxx20">(C++20)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../utility.html#Language_support" title="cpp/utility"> Language support library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../concepts.html" title="cpp/concepts"> Concepts library</a> <span class="t-mark-rev t-since-cxx20">(C++20)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../meta.html" title="cpp/meta"> Metaprogramming library</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../error.html" title="cpp/error"> Diagnostics library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../utility.html" title="cpp/utility"> General utilities library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../string.html" title="cpp/string"> Strings library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../container.html" title="cpp/container"> Containers library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../iterator.html" title="cpp/iterator"> Iterators library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../ranges.html" title="cpp/ranges"> Ranges library</a> <span class="t-mark-rev t-since-cxx20">(C++20)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../algorithm.html" title="cpp/algorithm"> Algorithms library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../numeric.html" title="cpp/numeric"> Numerics library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../locale.html" title="cpp/locale"> Localizations library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../io.html" title="cpp/io"> Input/output library</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../filesystem.html" title="cpp/filesystem"> Filesystem library</a> <span class="t-mark-rev t-since-cxx17">(C++17)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../regex.html" title="cpp/regex"> Regular expressions library</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../thread.html" title="cpp/thread"> Concurrency support library</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../experimental.html" title="cpp/experimental"> Technical specifications</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../symbol_index.html" title="cpp/symbol index"> Symbols index</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../links/libs.html" title="cpp/links/libs"> External libraries</a> </td></tr>
</table></div><div></div></div></div></div><div class="t-navbar-sep"> </div><div class="t-navbar-head"><a href="../language.html" title="cpp/language"> C++ language</a><div class="t-navbar-menu"><div><div style="display:inline-block">
<div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv-h1"><td colspan="5"> General topics</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="../preprocessor.html" title="cpp/preprocessor"> Preprocessor</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="../comments.html" title="cpp/comment"> Comments</a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="../keywords.html" title="cpp/keyword"> Keywords</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="escape.html" title="cpp/language/escape"> Escape sequences</a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h1"><td colspan="5"> <a href="statements.html" title="cpp/language/statements"> Flow control</a></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Conditional execution statements</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="if.html" title="cpp/language/if"><tt>if</tt></a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="switch.html" title="cpp/language/switch"><tt>switch</tt></a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Iteration statements (loops)</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="for.html" title="cpp/language/for"><tt>for</tt></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="range-for.html" title="cpp/language/range-for"> range-<code>for</code></a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="while.html" title="cpp/language/while"><tt>while</tt></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="do.html" title="cpp/language/do"> <code>do-while</code></a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Jump statements </td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="continue.html" title="cpp/language/continue"><tt>continue</tt></a> - <a href="break.html" title="cpp/language/break"><tt>break</tt></a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="goto.html" title="cpp/language/goto"><tt>goto</tt></a> - <a href="return.html" title="cpp/language/return"><tt>return</tt></a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h1"><td colspan="5"> <a href="functions.html" title="cpp/language/functions"> Functions</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="function.html" title="cpp/language/function"> Function declaration</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="lambda.html" title="cpp/language/lambda"> Lambda function expression</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="inline.html" title="cpp/language/inline"> <code>inline</code> specifier</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="except_spec.html" title="cpp/language/except spec"> Dynamic exception specifications</a> <span class="t-mark-rev t-until-cxx20">(until C++20)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="noexcept_spec.html" title="cpp/language/noexcept spec"> <code>noexcept</code> specifier</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv-h1"><td colspan="5"> Exceptions</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="throw.html" title="cpp/language/throw"> <code>throw</code>-expression</a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="try_catch.html" title="cpp/language/try catch"> <code>try</code>-<code>catch</code> block</a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h1"><td colspan="5"> Namespaces</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="namespace.html" title="cpp/language/namespace"> Namespace declaration</a>  </td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="namespace_alias.html" title="cpp/language/namespace alias"> Namespace aliases</a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h1"><td colspan="5"> Types</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="types.html" title="cpp/language/types"> Fundamental types</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="enum_class.html" title="cpp/language/enum"> Enumeration types</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="function.html" title="cpp/language/function"> Function types</a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="class.html" title="cpp/language/class"> Class/struct types</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="union.html" title="cpp/language/union"> Union types</a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Specifiers</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="decltype.html" title="cpp/language/decltype"><tt>decltype</tt></a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="auto.html" title="cpp/language/auto"><tt>auto</tt></a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="alignas.html" title="cpp/language/alignas"><tt>alignas</tt></a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="cv.html" title="cpp/language/cv"> <code>const</code>/<code>volatile</code></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="constexpr.html" title="cpp/language/constexpr"><tt>constexpr</tt></a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
</table></div></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="storage_duration.html" title="cpp/language/storage duration"> Storage duration specifiers</a></td></tr>
<tr class="t-nv-h2"><td colspan="5"> <a href="initialization.html" title="cpp/language/initialization"> Initialization</a></td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="default_initialization.html" title="cpp/language/default initialization"> Default initialization</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="value_initialization.html" title="cpp/language/value initialization"> Value initialization</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="zero_initialization.html" title="cpp/language/zero initialization"> Zero initialization</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="copy_initialization.html" title="cpp/language/copy initialization"> Copy initialization</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="direct_initialization.html" title="cpp/language/direct initialization"> Direct initialization</a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="aggregate_initialization.html" title="cpp/language/aggregate initialization"> Aggregate initialization</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="list_initialization.html" title="cpp/language/list initialization"> List initialization</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="constant_initialization.html" title="cpp/language/constant initialization"> Constant initialization</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="reference_initialization.html" title="cpp/language/reference initialization"> Reference initialization</a></td></tr>
</table></div></td></tr>
</table></div>
</div>
<div style="display:inline-block">
<div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv-h1"><td colspan="5"> <a href="expressions.html" title="cpp/language/expressions"> Expressions</a></td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="value_category.html" title="cpp/language/value category"> Value categories</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="eval_order.html" title="cpp/language/eval order"> Order of evaluation</a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="operators.html" title="cpp/language/operators"> Operators</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_precedence.html" title="cpp/language/operator precedence"> Operator precedence</a></td></tr>
</table></div></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_alternative.html" title="cpp/language/operator alternative"> Alternative representations</a></td></tr>
<tr class="t-nv-h2"><td colspan="5"> <a href="expressions.html#Literals" title="cpp/language/expressions"> Literals</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="bool_literal.html" title="cpp/language/bool literal"> Boolean</a> - <a href="integer_literal.html" title="cpp/language/integer literal"> Integer</a> - <a href="floating_literal.html" title="cpp/language/floating literal"> Floating-point</a></td></tr>   
<tr class="t-nv"><td colspan="5"> <a href="character_literal.html" title="cpp/language/character literal"> Character</a> - <a href="string_literal.html" title="cpp/language/string literal"> String</a> - <a href="nullptr.html" title="cpp/language/nullptr"><tt>nullptr</tt></a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr> 
<tr class="t-nv"><td colspan="5"> <a href="user_literal.html" title="cpp/language/user literal"> User-defined</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv-h1"><td colspan="5"> Utilities</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="attributes.html" title="cpp/language/attributes"> Attributes</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Types</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="typedef.html" title="cpp/language/typedef"> <code>typedef</code> declaration</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="type_alias.html" title="cpp/language/type alias"> Type alias declaration</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Casts</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="implicit_cast.html" title="cpp/language/implicit conversion"> Implicit conversions</a> - <a href="explicit_cast.html" title="cpp/language/explicit cast"> Explicit conversions</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="static_cast.html" title="cpp/language/static cast"><tt>static_cast</tt></a> - <a href="dynamic_cast.html" title="cpp/language/dynamic cast"><tt>dynamic_cast</tt></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="const_cast.html" title="cpp/language/const cast"><tt>const_cast</tt></a> - <a href="reinterpret_cast.html" title="cpp/language/reinterpret cast"><tt>reinterpret_cast</tt></a></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Memory allocation</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="new.html" title="cpp/language/new"> <code>new</code> expression</a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="delete.html" title="cpp/language/delete"> <code>delete</code> expression</a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h1"><td colspan="5"> <a href="classes.html" title="cpp/language/classes"> Classes</a></td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="class.html" title="cpp/language/class"> Class declaration</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="initializer_list.html" title="cpp/language/constructor"> Constructors</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="this.html" title="cpp/language/this"> <code>this</code> pointer</a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="access.html" title="cpp/language/access"> Access specifiers</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="friend.html" title="cpp/language/friend"> <code>friend</code> specifier</a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Class-specific function properties</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="virtual.html" title="cpp/language/virtual"> Virtual function</a> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="override.html" title="cpp/language/override"> <code>override</code> specifier</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="final.html" title="cpp/language/final"> <code>final</code> specifier</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="explicit.html" title="cpp/language/explicit"><tt>explicit</tt></a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="static.html" title="cpp/language/static"><tt>static</tt></a> </td></tr>
</table></div></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Special member functions</td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="default_constructor.html" title="cpp/language/default constructor"> Default constructor</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="copy_constructor.html" title="cpp/language/copy constructor"> Copy constructor</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="move_constructor.html" title="cpp/language/move constructor"> Move constructor</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="as_operator.html" title="cpp/language/as operator" class="mw-redirect"> Copy assignment</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="move_operator.html" title="cpp/language/move operator" class="mw-redirect"> Move assignment</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="destructor.html" title="cpp/language/destructor"> Destructor</a></td></tr>
</table></div></td></tr>
<tr class="t-nv-h1"><td colspan="5"><a href="templates.html" title="cpp/language/templates"> Templates</a> </td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="class_template.html" title="cpp/language/class template"> Class template </a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="function_template.html" title="cpp/language/function template"> Function template </a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="template_specialization.html" title="cpp/language/template specialization"> Template specialization</a></td></tr>   
<tr class="t-nv"><td colspan="5"> <a href="parameter_pack.html" title="cpp/language/parameter pack"> Parameter packs</a> <span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
</table></div></td></tr>
<tr class="t-nv-h1"><td colspan="5"> Miscellaneous </td></tr>
<tr class="t-nv-col-table"><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="asm.html" title="cpp/language/asm"> Inline assembly</a></td></tr>
</table></div></td><td><div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv"><td colspan="5"> <a href="history.html" title="cpp/language/history"> History of C++</a></td></tr>
</table></div></td></tr>
</table></div>
</div><div></div></div></div></div><div class="t-navbar-sep"> </div><div class="t-navbar-head"><a href="expressions.html" title="cpp/language/expressions"> Expressions</a><div class="t-navbar-menu"><div><div style="display:inline-block">
<div><table class="t-nv-begin" cellpadding="0" style="">
<tr class="t-nv-h2"><td colspan="5"> General </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="value_category.html" title="cpp/language/value category"> value categories</a> (lvalue, rvalue, xvalue)</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="eval_order.html" title="cpp/language/eval order"> order of evaluation</a> (sequence points)</td></tr>
<tr class="t-nv"><td colspan="5"> <a href="constant_expression.html" title="cpp/language/constant expression"> constant expressions</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="expressions.html#Unevaluated_expressions" title="cpp/language/expressions"> unevaluated expressions</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="expressions.html#Primary_expressions" title="cpp/language/expressions"> primary expressions</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="lambda.html" title="cpp/language/lambda">lambda-expression</a><span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Literals </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="integer_literal.html" title="cpp/language/integer literal">integer literals</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="floating_literal.html" title="cpp/language/floating literal">floating-point literals</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="bool_literal.html" title="cpp/language/bool literal">boolean literals</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="character_literal.html" title="cpp/language/character literal">character literals</a> including <a href="escape.html" title="cpp/language/escape">escape sequences</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="string_literal.html" title="cpp/language/string literal">string literals</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="nullptr.html" title="cpp/language/nullptr">null pointer literal</a><span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="user_literal.html" title="cpp/language/user literal">user-defined literal</a><span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Operators </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_assignment.html" title="cpp/language/operator assignment"> Assignment operators</a>: 
<code>a=b</code>, <code>a+=b</code>, <code>a-=b</code>, <code>a*=b</code>, <code>a/=b</code>, <code>a%=b</code>, <code>a&amp;=b</code>, <code>a|=b</code>, <code>a^=b</code>, <code>a&lt;&lt;=b</code>, <code>a&gt;&gt;=b</code></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_incdec.html" title="cpp/language/operator incdec"> Increment and decrement</a>: <code>++a</code>, <code>--a</code>, <code>a++</code>, <code>a--</code></td></tr>
<tr class="t-nv"><td colspan="5"> <strong class="selflink"> Arithmetic operators</strong>:
<code>+a</code>, <code>-a</code>, <code>a+b</code>, <code>a-b</code>, <code>a*b</code>, <code>a/b</code>, <code>a%b</code>, <code>~a</code>, <code>a&amp;b</code>, <code>a|b</code>, <code>a^b</code>, <code>a&lt;&lt;b</code>, <code>a&gt;&gt;b</code> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_logical.html" title="cpp/language/operator logical"> Logical operators</a>: <code>a||b</code>, <code>a&amp;&amp;b</code>, <code>!a</code></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_comparison.html" title="cpp/language/operator comparison"> Comparison operators</a>: <code>a==b</code>, <code>a!=b</code>, <code>a&lt;b</code>, <code>a&gt;b</code>, <code>a&lt;=b</code>, <code>a&gt;=b</code>, <code>a&lt;=&gt;b</code><span class="t-mark-rev t-since-cxx20">(C++20)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_member_access.html" title="cpp/language/operator member access"> Member access operators</a>: <code>a[b]</code>, <code>*a</code>, <code>&amp;a</code>, <code>a-&gt;b</code>, <code>a.b</code>, <code>a-&gt;*b</code>, <code>a.*b</code></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_other.html" title="cpp/language/operator other"> Other operators</a>: <code>a(...)</code>, <code>a,b</code>, <code>a?b:c</code> </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="new.html" title="cpp/language/new">new-expression</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="delete.html" title="cpp/language/delete">delete-expression</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="throw.html" title="cpp/language/throw">throw-expression</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="alignof.html" title="cpp/language/alignof"><code>alignof</code></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="sizeof.html" title="cpp/language/sizeof"><code>sizeof</code></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="sizeof....html" title="cpp/language/sizeof..."><code>sizeof...</code></a><span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="typeid.html" title="cpp/language/typeid"><code>typeid</code></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="noexcept.html" title="cpp/language/noexcept"><code>noexcept</code></a><span class="t-mark-rev t-since-cxx11">(C++11)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="fold.html" title="cpp/language/fold">Fold expression</a><span class="t-mark-rev t-since-cxx17">(C++17)</span></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_alternative.html" title="cpp/language/operator alternative">Alternative representations of operators</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operator_precedence.html" title="cpp/language/operator precedence">Precedence and associativity</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="operators.html" title="cpp/language/operators">Operator overloading</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="default_comparisons.html" title="cpp/language/default comparisons">Default comparisons</a><span class="t-mark-rev t-since-cxx20">(C++20)</span></td></tr>
<tr class="t-nv-h2"><td colspan="5"> Conversions </td></tr>
<tr class="t-nv"><td colspan="5"> <a href="implicit_cast.html" title="cpp/language/implicit conversion">Implicit conversions</a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="const_cast.html" title="cpp/language/const cast"><code>const_cast</code></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="static_cast.html" title="cpp/language/static cast"><code>static_cast</code></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="reinterpret_cast.html" title="cpp/language/reinterpret cast"><code>reinterpret_cast</code></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="dynamic_cast.html" title="cpp/language/dynamic cast"><code>dynamic_cast</code></a></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="explicit_cast.html" title="cpp/language/explicit cast">Explicit conversions</a> <code>(T)a</code>, <code>T(a)</code></td></tr>
<tr class="t-nv"><td colspan="5"> <a href="cast_operator.html" title="cpp/language/cast operator">User-defined conversion</a></td></tr>
</table></div>
</div><div></div></div></div></div><div class="t-navbar-sep"> </div></div>
<p>Returns the result of specific arithmetic operation.
</p>
<table class="wikitable" style="font-size:85%;">

<tr>
<th rowspan="2">Operator name
</th>
<th rowspan="2">Syntax
</th>
<th rowspan="2"><a href="operators.html" title="cpp/language/operators">Over​load​able</a>
</th>
<th colspan="2">Prototype examples (for <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw1">class</span> T</span></span>)
</th></tr>
<tr>
<th> Inside class definition
</th>
<th> Outside class definition
</th></tr>
<tr>
<td>unary plus
</td>
<td><code>+a</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T T<span class="sy4">::</span><span class="me2">operator</span><span class="sy2">+</span><span class="br0">(</span><span class="br0">)</span> <span class="kw4">const</span><span class="sy4">;</span></span></span>
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T operator<span class="sy2">+</span><span class="br0">(</span><span class="kw4">const</span> T <span class="sy3">&amp;</span>a<span class="br0">)</span><span class="sy4">;</span></span></span>
</td></tr>
<tr>
<td>unary minus
</td>
<td><code>-a</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T T<span class="sy4">::</span><span class="me2">operator</span><span class="sy2">-</span><span class="br0">(</span><span class="br0">)</span> <span class="kw4">const</span><span class="sy4">;</span></span></span>
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T operator<span class="sy2">-</span><span class="br0">(</span><span class="kw4">const</span> T <span class="sy3">&amp;</span>a<span class="br0">)</span><span class="sy4">;</span></span></span>
</td></tr>
<tr>
<td>addition
</td>
<td><code>a + b</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T T<span class="sy4">::</span><span class="me2">operator</span><span class="sy2">+</span><span class="br0">(</span><span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span> <span class="kw4">const</span><span class="sy4">;</span></span></span>
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T operator<span class="sy2">+</span><span class="br0">(</span><span class="kw4">const</span> T <span class="sy3">&amp;</span>a, <span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span><span class="sy4">;</span></span></span>
</td></tr>
<tr>
<td>subtraction
</td>
<td><code>a - b</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T T<span class="sy4">::</span><span class="me2">operator</span><span class="sy2">-</span><span class="br0">(</span><span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span> <span class="kw4">const</span><span class="sy4">;</span></span></span>
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T operator<span class="sy2">-</span><span class="br0">(</span><span class="kw4">const</span> T <span class="sy3">&amp;</span>a, <span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span><span class="sy4">;</span></span></span>
</td></tr>
<tr>
<td>multiplication
</td>
<td><code>a * b</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T T<span class="sy4">::</span><span class="me2">operator</span><span class="sy2">*</span><span class="br0">(</span><span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span> <span class="kw4">const</span><span class="sy4">;</span></span></span>
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T operator<span class="sy2">*</span><span class="br0">(</span><span class="kw4">const</span> T <span class="sy3">&amp;</span>a, <span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span><span class="sy4">;</span></span></span>
</td></tr>
<tr>
<td>division
</td>
<td><code>a / b</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T T<span class="sy4">::</span><span class="me2">operator</span><span class="sy2">/</span><span class="br0">(</span><span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span> <span class="kw4">const</span><span class="sy4">;</span></span></span>
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T operator<span class="sy2">/</span><span class="br0">(</span><span class="kw4">const</span> T <span class="sy3">&amp;</span>a, <span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span><span class="sy4">;</span></span></span>
</td></tr>
<tr>
<td>modulo
</td>
<td><code>a % b</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T T<span class="sy4">::</span><span class="me2">operator</span><span class="sy2">%</span><span class="br0">(</span><span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span> <span class="kw4">const</span><span class="sy4">;</span></span></span>
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T operator<span class="sy2">%</span><span class="br0">(</span><span class="kw4">const</span> T <span class="sy3">&amp;</span>a, <span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span><span class="sy4">;</span></span></span>
</td></tr>
<tr>
<td>bitwise NOT
</td>
<td><code>~a</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T T<span class="sy4">::</span><span class="me2">operator</span>~<span class="br0">(</span><span class="br0">)</span> <span class="kw4">const</span><span class="sy4">;</span></span></span>
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T operator~<span class="br0">(</span><span class="kw4">const</span> T <span class="sy3">&amp;</span>a<span class="br0">)</span><span class="sy4">;</span></span></span>
</td></tr>
<tr>
<td>bitwise AND
</td>
<td><code>a &amp; b</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T T<span class="sy4">::</span><span class="me2">operator</span><span class="sy3">&amp;</span><span class="br0">(</span><span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span> <span class="kw4">const</span><span class="sy4">;</span></span></span>
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T operator<span class="sy3">&amp;</span><span class="br0">(</span><span class="kw4">const</span> T <span class="sy3">&amp;</span>a, <span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span><span class="sy4">;</span></span></span>
</td></tr>
<tr>
<td>bitwise OR
</td>
<td><code>a | b</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T T<span class="sy4">::</span><span class="me2">operator</span><span class="sy3">|</span><span class="br0">(</span><span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span> <span class="kw4">const</span><span class="sy4">;</span></span></span>
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T operator<span class="sy3">|</span><span class="br0">(</span><span class="kw4">const</span> T <span class="sy3">&amp;</span>a, <span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span><span class="sy4">;</span></span></span>
</td></tr>
<tr>
<td>bitwise XOR
</td>
<td><code>a ^ b</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T T<span class="sy4">::</span><span class="me2">operator</span><span class="sy3">^</span><span class="br0">(</span><span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span> <span class="kw4">const</span><span class="sy4">;</span></span></span>
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T operator<span class="sy3">^</span><span class="br0">(</span><span class="kw4">const</span> T <span class="sy3">&amp;</span>a, <span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span><span class="sy4">;</span></span></span>
</td></tr>
<tr>
<td>bitwise left shift
</td>
<td><code>a &lt;&lt; b</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T T<span class="sy4">::</span><span class="me2">operator</span><span class="sy1">&lt;&lt;</span><span class="br0">(</span><span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span> <span class="kw4">const</span><span class="sy4">;</span></span></span>
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T operator<span class="sy1">&lt;&lt;</span><span class="br0">(</span><span class="kw4">const</span> T <span class="sy3">&amp;</span>a, <span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span><span class="sy4">;</span></span></span>
</td></tr>
<tr>
<td>bitwise right shift
</td>
<td><code>a &gt;&gt; b</code>
</td>
<td style="background: #90ff90; color: black; vertical-align: middle; text-align: center;" class="table-yes">Yes
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T T<span class="sy4">::</span><span class="me2">operator</span><span class="sy1">&gt;&gt;</span><span class="br0">(</span><span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span> <span class="kw4">const</span><span class="sy4">;</span></span></span>
</td>
<td><span class="t-c"><span class="mw-geshi cpp source-cpp">T operator<span class="sy1">&gt;&gt;</span><span class="br0">(</span><span class="kw4">const</span> T <span class="sy3">&amp;</span>a, <span class="kw4">const</span> T2 <span class="sy3">&amp;</span>b<span class="br0">)</span><span class="sy4">;</span></span></span>
</td></tr>
<tr>
<td colspan="5">
<dl><dd><b>Notes</b><br>
</dd></dl>
<ul><li> All built-in operators return values, and most <a href="operators.html" title="cpp/language/operators">user-defined overloads</a> also return values so that the user-defined operators can be used in the same manner as the built-ins. However, in a user-defined operator overload, any type can be used as return type (including <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">void</span></span></span>). In particular, stream insertion and stream extraction overloads of <code>operator&lt;&lt;</code> and <code>operator&gt;&gt;</code> return <code>T&amp;</code>.
</li><li> <code>T2</code> can be any type including <code>T</code>
</li></ul>
</td></tr></table>
<h3><span class="mw-headline" id="Explanation">Explanation</span></h3>
<p>All arithmetic operators compute the result of specific arithmetic operation and returns its result. The arguments are not modified.
</p>
<h4><span class="mw-headline" id="Conversions">Conversions</span></h4>
<p>If the operand passed to an arithmetic operator is integral or unscoped enumeration type, then before any other action (but after lvalue-to-rvalue conversion, if applicable), the operand undergoes <a href="implicit_cast.html#Integral_promotion" title="cpp/language/implicit conversion">integral promotion</a>. If an operand has array or function type, <a href="implicit_cast.html#array_to_pointer_conversion" title="cpp/language/implicit conversion">array-to-pointer</a> and <a href="implicit_cast.html#function_to_pointer" title="cpp/language/implicit conversion">function-to-pointer</a> conversions are applied.
</p><p>For the binary operators (except shifts), if the promoted operands have different types, additional set of implicit conversions is applied, known as <i>usual arithmetic conversions</i> with the goal to produce the <i>common type</i> (also accessible via the <span class="t-lc"><a href="../types/common_type.html" title="cpp/types/common type">std::common_type</a></span> type trait). <span class="t-rev-inl t-since-cxx20"><span>If, prior to any integral promotion, one operand is of enumeration type and the other operand is of a floating-point type or a different enumeration type, this behavior is deprecated.</span> <span><span class="t-mark-rev t-since-cxx20">(since C++20)</span></span></span>
</p>
<ul><li> If either operand has <a href="enum_class.html" title="cpp/language/enum class" class="mw-redirect">scoped enumeration type</a>, no conversion is performed: the other operand and the return type must have the same type.
</li></ul>
<ul><li> Otherwise, if either operand is <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">long</span> <span class="kw4">double</span></span></span>, the other operand is converted to <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">long</span> <span class="kw4">double</span></span></span>.
</li></ul>
<ul><li> Otherwise, if either operand is <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">double</span></span></span>, the other operand is converted to <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">double</span></span></span>.
</li></ul>
<ul><li> Otherwise, if either operand is <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">float</span></span></span>, the other operand is converted to <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">float</span></span></span>.
</li></ul>
<ul><li> Otherwise, the operand has integer type (because <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">bool</span></span></span>, <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">char</span></span></span>,<span class="t-rev-inl t-since-cxx20"><span> <span class="t-c"><span class="mw-geshi cpp source-cpp">char8_t</span></span>,</span> <span><span class="t-mark-rev t-since-cxx20">(since C++20)</span></span></span><span class="t-rev-inl t-since-cxx11"><span> <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">char16_t</span></span></span>, <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">char32_t</span></span></span>,</span> <span><span class="t-mark-rev t-since-cxx11">(since C++11)</span></span></span> <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">wchar_t</span></span></span>, and unscoped enumeration were promoted at this point) and <a href="implicit_cast.html#Integral_conversions" title="cpp/language/implicit conversion">integral conversions</a> are applied to produce the common type, as follows:
</li></ul>
<dl><dd><ul><li> If both operands are signed or both are unsigned, the operand with lesser <i>conversion rank</i> is converted to the operand with the greater integer conversion rank.
</li></ul>
</dd></dl>
<dl><dd><ul><li> Otherwise, if the unsigned operand's conversion rank is greater or equal to the conversion rank of the signed operand, the signed operand is converted to the unsigned operand's type.
</li></ul>
</dd></dl>
<dl><dd><ul><li> Otherwise, if the signed operand's type can represent all values of the unsigned operand, the unsigned operand is converted to the signed operand's type.
</li></ul>
</dd></dl>
<dl><dd><ul><li> Otherwise, both operands are converted to the unsigned counterpart of the signed operand's type.
</li></ul>
</dd></dl>
<p>The <i>conversion rank</i> above increases in order <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">bool</span></span></span>, <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">signed</span> <span class="kw4">char</span></span></span>, <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">short</span></span></span>, <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">int</span></span></span>, <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">long</span></span></span><span class="t-rev-inl t-since-cxx11"><span>, <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">long</span> <span class="kw4">long</span></span></span></span> <span><span class="t-mark-rev t-since-cxx11">(since C++11)</span></span></span>. The rank of any unsigned type is equal to the rank of the corresponding signed type. The rank of <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">char</span></span></span> is equal to the rank of <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">signed</span> <span class="kw4">char</span></span></span> and <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">unsigned</span> <span class="kw4">char</span></span></span>. The ranks of <span class="t-rev-inl t-since-cxx20"><span><span class="t-c"><span class="mw-geshi cpp source-cpp">char8_t</span></span>, </span> <span><span class="t-mark-rev t-since-cxx20">(since C++20)</span></span></span><span class="t-rev-inl t-since-cxx11"><span><span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">char16_t</span></span></span>, <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">char32_t</span></span></span>, and </span> <span><span class="t-mark-rev t-since-cxx11">(since C++11)</span></span></span><span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">wchar_t</span></span></span> are equal to the ranks of their corresponding underlying types.
</p>
<h4><span class="mw-headline" id="Overflows">Overflows</span></h4>
<p>Unsigned integer arithmetic is always performed <span class="texhtml" style="white-space: nowrap;">modulo 2<span class="t-su">n<br></span></span> where n is the number of bits in that particular integer. E.g. for <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">unsigned</span> <span class="kw4">int</span></span></span>, adding one to <span class="t-lc"><a href="../types/climits.html" title="cpp/types/climits">UINT_MAX</a></span> gives <span class="t-c"><span class="mw-geshi cpp source-cpp">​<span class="nu0">0</span>​</span></span>, and subtracting one from <span class="t-c"><span class="mw-geshi cpp source-cpp">​<span class="nu0">0</span>​</span></span> gives <span class="t-lc"><a href="../types/climits.html" title="cpp/types/climits">UINT_MAX</a></span>.
</p><p>When signed integer arithmetic operation overflows (the result does not fit in the result type), the behavior is undefined, — the possible manifestations of such an operation include:
</p>
<ul><li> it wraps around according to the rules of the representation (typically 2's complement),
</li><li> it traps — on some platforms or due to compiler options (e.g. <code>-ftrapv</code> in GCC and Clang),
</li><li> it saturates to minimal or maximal value (on many DSPs),
</li><li> it is completely <a rel="nofollow" class="external text" href="http://blog.llvm.org/2011/05/what-every-c-programmer-should-know_14.html">optimized out by the compiler</a>.
</li></ul>
<h4><span class="mw-headline" id="Floating-point_environment">Floating-point environment</span></h4>
<p>If <a href="../preprocessor/impl.html" title="cpp/preprocessor/impl"><tt>
#pragma STDC FENV_ACCESS</tt></a> is supported and set to <code>ON</code>, all floating-point arithmetic operators obey the current floating-point <a href="../numeric/fenv/FE_round.html" title="cpp/numeric/fenv/FE round">rounding direction</a> and report floating-point arithmetic errors as specified in <a href="../numeric/math/math_errhandling.html" title="cpp/numeric/math/math errhandling"><tt>math_errhandling</tt></a> unless part of a <a href="initialization.html#Non-local_variables" title="cpp/language/initialization">static initializer</a> (in which case floating-point exceptions are not raised and the rounding mode is to nearest)
</p>
<h4><span class="mw-headline" id="Floating-point_contraction">Floating-point contraction</span></h4>
<p>Unless <a href="../preprocessor/impl.html" title="cpp/preprocessor/impl"><tt>
#pragma STDC FP_CONTRACT</tt></a> is supported and set to <code>OFF</code>, all floating-point arithmetic may be performed as if the intermediate results have infinite range and precision, that is, optimizations that omit rounding errors and floating-point exceptions are allowed. For example, C++ allows the implementation of <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="br0">(</span>x <span class="sy2">*</span> y<span class="br0">)</span> <span class="sy2">+</span> z</span></span> with a single fused multiply-add CPU instruction or optimization of <span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy1">=</span> x <span class="sy2">*</span> x <span class="sy2">*</span> x <span class="sy2">*</span> x<span class="sy4">;</span></span></span> as <span class="t-c"><span class="mw-geshi cpp source-cpp">tmp <span class="sy1">=</span> x <span class="sy2">*</span> x<span class="sy4">;</span> a <span class="sy1">=</span> tmp <span class="sy2">*</span> tmp</span></span>. 
</p><p>Unrelated to contracting, intermediate results of floating-point arithmetic may have range and precision that is different from the one indicated by its type, see <span class="t-lc"><a href="../types/climits/FLT_EVAL_METHOD.html" title="cpp/types/climits/FLT EVAL METHOD">FLT_EVAL_METHOD</a></span>
</p><p>Formally, the C++ standard makes no guarantee on the accuracy of floating-point operations.
</p>
<h4><span class="mw-headline" id="Unary_arithmetic_operators">Unary arithmetic operators</span></h4>
<p>The unary arithmetic operator expressions have the form 
</p>
<table class="t-sdsc-begin">

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <code><b>+</b></code> <span class="t-spar">expression</span>
</td>
<td> (1)
</td>
<td class="t-sdsc-nopad">
</td></tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <code><b>-</b></code> <span class="t-spar">expression</span>
</td>
<td> (2)
</td>
<td class="t-sdsc-nopad">
</td></tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr></table>
<div class="t-li1"><span class="t-li">1)</span> unary plus (promotion).</div>
<div class="t-li1"><span class="t-li"></span> For the built-in operator, <span class="t-spar">expression</span> must have arithmetic, unscoped enumeration, or pointer type. Integral promotion is performed on the operand if it has integral or unscoped enumeration type and determines the type of the result.</div>
<div class="t-li1"><span class="t-li">2)</span> unary minus (negation).</div>
<div class="t-li1"><span class="t-li"></span> For the built-in operator, <span class="t-spar">expression</span> must have arithmetic or unscoped enumeration type. Integral promotion is performed on the operand and determines the type of the result.</div>
<p>The built-in unary plus operator returns the value of its operand. The only situation where it is not a no-op is when the operand has integral type or unscoped enumeration type, which is changed by integral promotion, e.g, it converts <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">char</span></span></span> to <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">int</span></span></span> or if the operand is subject to lvalue-to-rvalue, array-to-pointer, or function-to-pointer conversion.
</p><p>The builtin unary minus operator calculates the negative of its promoted operand. For unsigned <code>a</code>, the value of <code>-a</code> is <span class="texhtml" style="white-space: nowrap;">2<span class="t-su">b<br></span>-a</span>, where <code>b</code> is the number of bits after promotion.
</p><p>In <a href="overload_resolution.html#Call_to_an_overloaded_operator" title="cpp/language/overload resolution">overload resolution against user-defined operators</a>, for every cv-unqualified promoted arithmetic type <code>A</code> and for every type <code>T</code>, the following function signatures participate in overload resolution:
</p>
<table class="t-dcl-begin"><tbody>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">A operator<span class="sy2">+</span><span class="br0">(</span>A<span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">T<span class="sy2">*</span> operator<span class="sy2">+</span><span class="br0">(</span>T<span class="sy2">*</span><span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">A operator<span class="sy2">-</span><span class="br0">(</span>A<span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr> 
<tr class="t-dcl-sep"><td></td><td></td><td></td></tr>
</tbody></table>
<div class="t-example"><div class="t-example-live-link"><div class="coliru-btn coliru-btn-run-init">Run this code</div></div>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="co2">#include &lt;iostream&gt;</span>
 
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
    <span class="kw4">char</span> c <span class="sy1">=</span> <span class="nu12">0x6a</span><span class="sy4">;</span>
    <span class="kw4">int</span> n1 <span class="sy1">=</span> <span class="nu0">1</span><span class="sy4">;</span>
    <span class="kw4">unsigned</span> <span class="kw4">char</span> n2 <span class="sy1">=</span> <span class="nu0">1</span><span class="sy4">;</span>
    <span class="kw4">unsigned</span> <span class="kw4">int</span> n3 <span class="sy1">=</span> <span class="nu0">1</span><span class="sy4">;</span>
    <a href="../io/cout.html"><span class="kw1762">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span> <span class="st0">"char: "</span> <span class="sy1">&lt;&lt;</span> c <span class="sy1">&lt;&lt;</span> <span class="st0">" int: "</span> <span class="sy1">&lt;&lt;</span> <span class="sy2">+</span>c <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span>
              <span class="sy1">&lt;&lt;</span> <span class="st0">"-1, where 1 is signed: "</span> <span class="sy1">&lt;&lt;</span> <span class="sy2">-</span>n1 <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span>
              <span class="sy1">&lt;&lt;</span> <span class="st0">"-1, where 1 is unsigned char: "</span> <span class="sy1">&lt;&lt;</span> <span class="sy2">-</span>n2 <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span>
              <span class="sy1">&lt;&lt;</span> <span class="st0">"-1, where 1 is unsigned int: "</span> <span class="sy1">&lt;&lt;</span> <span class="sy2">-</span>n3 <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span><span class="sy4">;</span>
    <span class="kw4">char</span> a<span class="br0">[</span><span class="nu0">3</span><span class="br0">]</span><span class="sy4">;</span>
    <a href="../io/cout.html"><span class="kw1762">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span> <span class="st0">"size of array: "</span> <span class="sy1">&lt;&lt;</span> sizeof a <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span>
              <span class="sy1">&lt;&lt;</span> <span class="st0">"size of pointer: "</span> <span class="sy1">&lt;&lt;</span> sizeof <span class="sy2">+</span>a <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span><span class="sy4">;</span>
<span class="br0">}</span></pre></div></div>
<p>Possible output:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="text source-text"><pre class="de1">char: j int: 106
-1, where 1 is signed: -1
-1, where 1 is unsigned char: -1
-1, where 1 is unsigned int: 4294967295
size of array: 3
size of pointer: 8</pre></div></div> 
</div>
<h4><span class="mw-headline" id="Additive_operators">Additive operators</span></h4>
<p>The binary additive arithmetic operator expressions have the form 
</p>
<table class="t-sdsc-begin">

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">lhs</span> <code><b>+</b></code> <span class="t-spar">rhs</span>
</td>
<td> (1)
</td>
<td class="t-sdsc-nopad">
</td></tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">lhs</span> <code><b>-</b></code> <span class="t-spar">rhs</span>
</td>
<td> (2)
</td>
<td class="t-sdsc-nopad">
</td></tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr></table>
<div class="t-li1"><span class="t-li">1)</span> addition</div>
<div class="t-li1"><span class="t-li"></span> For the built-in operator, <span class="t-spar">lhs</span> and <span class="t-spar">rhs</span> must be one of the following:
<dl><dd><ul><li> both have arithmetic or unscoped enumeration type. In this case, the usual arithmetic conversions are performed on both operands and determine the type of the result.
</li><li> one is a pointer to completely-defined object type, the other has integral or unscoped enumeration type. In this case, the result type has the type of the pointer.</li></ul></dd></dl></div>


<div class="t-li1"><span class="t-li">2)</span> subtraction</div>
<div class="t-li1"><span class="t-li"></span> For the built-in operator, <span class="t-spar">lhs</span> and <span class="t-spar">rhs</span> must be one of the following:
<dl><dd><ul><li> both have arithmetic or unscoped enumeration type. In this case, the usual arithmetic conversions are performed on both operands and determine the type of the result.
</li><li> <span class="t-spar">lhs</span> is a pointer to completely-defined object type, <span class="t-spar">rhs</span> has integral or unscoped enumeration type. In this case, the result type has the type of the pointer.
</li><li> both are pointers to the same completely-defined object types, ignoring cv-qualifiers. In this case, the result type is <span class="t-lc"><a href="../types/ptrdiff_t.html" title="cpp/types/ptrdiff t">std::ptrdiff_t</a></span>.</li></ul></dd></dl></div>


<p>With operands of arithmetic or enumeration type, the result of binary plus is the sum of the operands (after usual arithmetic conversions), and the result of the binary minus operator is the result of subtracting the second operand from the first (after usual arithmetic conversions), except that, if the type supports IEEE floating-point arithmetic (see <span class="t-lc"><a href="../types/numeric_limits/is_iec559.html" title="cpp/types/numeric limits/is iec559">std::numeric_limits::is_iec559</a></span>),
</p>
<dl><dd><ul><li> if one operand is NaN, the result is NaN
</li><li> infinity minus infinity is NaN and <span class="t-lc"><a href="../numeric/fenv/FE_exceptions.html" title="cpp/numeric/fenv/FE exceptions">FE_INVALID</a></span> is raised
</li><li> infinity plus the negative infinity is NaN and <span class="t-lc"><a href="../numeric/fenv/FE_exceptions.html" title="cpp/numeric/fenv/FE exceptions">FE_INVALID</a></span> is raised
</li></ul>
</dd></dl>
<p>If any of the operands is a pointer, the following rules apply:
</p>
<ul><li> A pointer to non-array object is treated as a pointer to the first element of an array with size 1.
</li><li> If the pointer <span class="t-c"><span class="mw-geshi cpp source-cpp">P</span></span> points to the <code>i</code>th element of an array, then the expressions <span class="t-c"><span class="mw-geshi cpp source-cpp">P <span class="sy2">+</span> n</span></span>, <span class="t-c"><span class="mw-geshi cpp source-cpp">n <span class="sy2">+</span> P</span></span>, and <span class="t-c"><span class="mw-geshi cpp source-cpp">P <span class="sy2">-</span> n</span></span> are pointers of the same type that point to the <code>i+n</code>th, <code>i+n</code>th, and <code>i-n</code>th element of the same array, respectively. The result of pointer addition may also be a one-past-the-end pointer (that is, pointer <span class="t-c"><span class="mw-geshi cpp source-cpp">P</span></span> such that the expression <span class="t-c"><span class="mw-geshi cpp source-cpp">P <span class="sy2">-</span> <span class="nu0">1</span></span></span> points to the last element of the array). Any other situations (that is, attempts to generate a pointer that isn't pointing at an element of the same array or one past the end) invoke undefined behavior.
</li><li> If the pointer <span class="t-c"><span class="mw-geshi cpp source-cpp">P</span></span> points to the <code>i</code>th element of an array, and the pointer <span class="t-c"><span class="mw-geshi cpp source-cpp">Q</span></span> points at the <code>j</code>th element of the same array, the expression <span class="t-c"><span class="mw-geshi cpp source-cpp">P <span class="sy2">-</span> Q</span></span> has the value <span class="t-c"><span class="mw-geshi cpp source-cpp">i <span class="sy2">-</span> j</span></span>, if the value fits in <span class="t-lc"><a href="../types/ptrdiff_t.html" title="cpp/types/ptrdiff t">std::ptrdiff_t</a></span>. Both operands must point to the elements of the same array (or one past the end), otherwise the behavior is undefined. If the result does not fit in <span class="t-lc"><a href="../types/ptrdiff_t.html" title="cpp/types/ptrdiff t">std::ptrdiff_t</a></span>, the behavior is undefined.
</li><li> In any case, if the pointed-to type is different from the array element type, disregarding cv-qualifications, at every level if the elements are themselves pointers, the behavior of pointer arithmetic is undefined. In particular, pointer arithmetic with pointer to base, which is pointing at an element of an array of derived objects is undefined.
</li><li> If the value <span class="t-c"><span class="mw-geshi cpp source-cpp">​<span class="nu0">0</span>​</span></span> is added or subtracted from a pointer, the result is the pointer, unchanged. If two pointers point at the same object or are both one past the end of the same array, or both are null pointers, then the result of subtraction is equal to <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="br0">(</span><a href="../types/ptrdiff_t.html"><span class="kw107">std::<span class="me2">ptrdiff_t</span></span></a><span class="br0">)</span><span class="nu0">0</span></span></span>.
</li></ul>
<p>These pointer arithmetic operators allow pointers to satisfy the <a href="../named_req/RandomAccessIterator.html" title="cpp/named req/RandomAccessIterator"><span style="font-family: Georgia, 'DejaVu Serif', serif; font-style:italic">LegacyRandomAccessIterator</span></a> requirements.
</p><p>In <a href="overload_resolution.html#Call_to_an_overloaded_operator" title="cpp/language/overload resolution">overload resolution against user-defined operators</a>, for every pair of promoted arithmetic types <code>L</code> and <code>R</code> and for every object type <code>T</code>, the following function signatures participate in overload resolution:
</p>
<table class="t-dcl-begin"><tbody>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">LR operator<span class="sy2">+</span><span class="br0">(</span>L, R<span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">LR operator<span class="sy2">-</span><span class="br0">(</span>L, R<span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">T<span class="sy2">*</span> operator<span class="sy2">+</span><span class="br0">(</span>T<span class="sy2">*</span>, <a href="../types/ptrdiff_t.html"><span class="kw107">std::<span class="me2">ptrdiff_t</span></span></a><span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">T<span class="sy2">*</span> operator<span class="sy2">+</span><span class="br0">(</span><a href="../types/ptrdiff_t.html"><span class="kw107">std::<span class="me2">ptrdiff_t</span></span></a>, T<span class="sy2">*</span><span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">T<span class="sy2">*</span> operator<span class="sy2">-</span><span class="br0">(</span>T<span class="sy2">*</span>, <a href="../types/ptrdiff_t.html"><span class="kw107">std::<span class="me2">ptrdiff_t</span></span></a><span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp"><a href="../types/ptrdiff_t.html"><span class="kw107">std::<span class="me2">ptrdiff_t</span></span></a> operator<span class="sy2">-</span><span class="br0">(</span>T<span class="sy2">*</span>, T<span class="sy2">*</span><span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl-sep"><td></td><td></td><td></td></tr>
</tbody></table>
<p>where <code>LR</code> is the result of usual arithmetic conversions on <code>L</code> and <code>R</code>.
</p>
<div class="t-example"><div class="t-example-live-link"><div class="coliru-btn coliru-btn-run-init">Run this code</div></div>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="co2">#include &lt;iostream&gt;</span>
 
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
    <span class="kw4">char</span> c <span class="sy1">=</span> <span class="nu0">2</span><span class="sy4">;</span>
    <span class="kw4">unsigned</span> <span class="kw4">int</span> un <span class="sy1">=</span> <span class="nu0">2</span><span class="sy4">;</span>
    <span class="kw4">int</span>  n <span class="sy1">=</span> <span class="sy2">-</span><span class="nu0">10</span><span class="sy4">;</span>
    <a href="../io/cout.html"><span class="kw1762">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span>  <span class="st0">" 2 + (-10), where 2 is a char    = "</span> <span class="sy1">&lt;&lt;</span> c <span class="sy2">+</span> n <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span>
              <span class="sy1">&lt;&lt;</span>  <span class="st0">" 2 + (-10), where 2 is unsigned  = "</span> <span class="sy1">&lt;&lt;</span> un <span class="sy2">+</span> n <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span>
              <span class="sy1">&lt;&lt;</span>  <span class="st0">" -10 - 2.12  = "</span> <span class="sy1">&lt;&lt;</span> n <span class="sy2">-</span> <span class="nu16">2.12</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span><span class="sy4">;</span>
 
    <span class="kw4">char</span> a<span class="br0">[</span><span class="nu0">4</span><span class="br0">]</span> <span class="sy1">=</span> <span class="br0">{</span><span class="st0">'a'</span>, <span class="st0">'b'</span>, <span class="st0">'c'</span>, <span class="st0">'d'</span><span class="br0">}</span><span class="sy4">;</span>
    <span class="kw4">char</span><span class="sy2">*</span> p <span class="sy1">=</span> <span class="sy3">&amp;</span>a<span class="br0">[</span><span class="nu0">1</span><span class="br0">]</span><span class="sy4">;</span>
    <a href="../io/cout.html"><span class="kw1762">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span> <span class="st0">"Pointer addition examples: "</span> <span class="sy1">&lt;&lt;</span> <span class="sy2">*</span>p <span class="sy1">&lt;&lt;</span> <span class="sy2">*</span><span class="br0">(</span>p <span class="sy2">+</span> <span class="nu0">2</span><span class="br0">)</span>
              <span class="sy1">&lt;&lt;</span> <span class="sy2">*</span><span class="br0">(</span><span class="nu0">2</span> <span class="sy2">+</span> p<span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="sy2">*</span><span class="br0">(</span>p <span class="sy2">-</span> <span class="nu0">1</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span><span class="sy4">;</span>
    <span class="kw4">char</span><span class="sy2">*</span> p2 <span class="sy1">=</span> <span class="sy3">&amp;</span>a<span class="br0">[</span><span class="nu0">4</span><span class="br0">]</span><span class="sy4">;</span>
    <a href="../io/cout.html"><span class="kw1762">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span> <span class="st0">"Pointer difference: "</span> <span class="sy1">&lt;&lt;</span> p2 <span class="sy2">-</span> p <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span><span class="sy4">;</span>
<span class="br0">}</span></pre></div></div>
<p>Output:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="text source-text"><pre class="de1">
 2 + (-10), where 2 is a char    = -8
 2 + (-10), where 2 is unsigned  = 4294967288
 -10 - 2.12  = -12.12
Pointer addition examples: bdda
Pointer difference: 3</pre></div></div> 
</div>
<h4><span class="mw-headline" id="Multiplicative_operators">Multiplicative operators</span></h4>
<p>The binary multiplicative arithmetic operator expressions have the form 
</p>
<table class="t-sdsc-begin">

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">lhs</span> <code><b>*</b></code> <span class="t-spar">rhs</span>
</td>
<td> (1)
</td>
<td class="t-sdsc-nopad">
</td></tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">lhs</span> <code><b>/</b></code> <span class="t-spar">rhs</span>
</td>
<td> (2)
</td>
<td class="t-sdsc-nopad">
</td></tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">lhs</span> <code><b>%</b></code> <span class="t-spar">rhs</span>
</td>
<td> (3)
</td>
<td class="t-sdsc-nopad">
</td></tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr></table>
<div class="t-li1"><span class="t-li">1)</span> multiplication</div>
<div class="t-li1"><span class="t-li"></span> For the built-in operator, <span class="t-spar">lhs</span> and <span class="t-spar">rhs</span> must both have arithmetic or unscoped enumeration type. </div>
<div class="t-li1"><span class="t-li">2)</span> division</div>
<div class="t-li1"><span class="t-li"></span> For the built-in operator, <span class="t-spar">lhs</span> and <span class="t-spar">rhs</span> must both have arithmetic or unscoped enumeration type. </div>
<div class="t-li1"><span class="t-li">3)</span> remainder</div>
<div class="t-li1"><span class="t-li"></span> For the built-in operator, <span class="t-spar">lhs</span> and <span class="t-spar">rhs</span> must both have integral or unscoped enumeration type</div>
<p>For all three operators, the usual arithmetic conversions are performed on both operands and determine the type of the result.
</p><p>The binary operator * performs multiplication of its operands (after usual arithmetic conversions), except that, for floating-point multiplication,
</p>
<ul><li> multiplication of a NaN by any number gives NaN
</li><li> multiplication of infinity by zero gives NaN and <span class="t-lc"><a href="../numeric/fenv/FE_exceptions.html" title="cpp/numeric/fenv/FE exceptions">FE_INVALID</a></span> is raised
</li></ul>
<p>The binary operator / divides the first operand by the second (after usual arithmetic conversions).
</p><p>For integral operands, it yields the algebraic quotient.
The quotient is truncated towards zero (fractional part is discarded).
</p><p>If the second operand is zero, the behavior is undefined, except that if floating-point division is taking place and the type supports IEEE floating-point arithmetic (see <span class="t-lc"><a href="../types/numeric_limits/is_iec559.html" title="cpp/types/numeric limits/is iec559">std::numeric_limits::is_iec559</a></span>), then:
</p>
<ul><li> if one operand is NaN, the result is NaN
</li><li> dividing a non-zero number by ±0.0 gives the correctly-signed infinity and <span class="t-lc"><a href="../numeric/fenv/FE_exceptions.html" title="cpp/numeric/fenv/FE exceptions">FE_DIVBYZERO</a></span> is raised
</li><li> dividing 0.0 by 0.0 gives NaN and <span class="t-lc"><a href="../numeric/fenv/FE_exceptions.html" title="cpp/numeric/fenv/FE exceptions">FE_INVALID</a></span> is raised
</li></ul>
<p>The binary operator % yields the remainder of the integer division of the first operand by the second (after usual arithmetic conversions; note that the operand types must be integral types). If the quotient <span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy2">/</span> b</span></span> is representable in the result type, <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="br0">(</span>a <span class="sy2">/</span> b<span class="br0">)</span> <span class="sy2">*</span> b <span class="sy2">+</span> a <span class="sy2">%</span> b <span class="sy1">==</span> a</span></span>. If the second operand is zero, the behavior is undefined. If the quotient <span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy2">/</span> b</span></span> is not representable in the result type, the behavior of both <span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy2">/</span> b</span></span> and <span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy2">%</span> b</span></span> is undefined (that means <span class="t-c"><span class="mw-geshi cpp source-cpp"><a href="../types/climits.html"><span class="kw399">INT_MIN</span></a> <span class="sy2">%</span> <span class="sy2">-</span><span class="nu0">1</span></span></span> is undefined on 2's complement systems)
</p><p>Note: Until <a rel="nofollow" class="external text" href="https://cplusplus.github.io/CWG/issues/614.html">CWG issue 614</a> was resolved (<a rel="nofollow" class="external text" href="https://wg21.link/n2757">N2757</a>), if one or both operands to binary operator % were negative, the sign of the remainder was implementation-defined, as it depends on the rounding direction of integer division. The function <span class="t-lc"><a href="../numeric/math/div.html" title="cpp/numeric/math/div">std::div</a></span> provided well-defined behavior in that case.
</p><p>Note: for floating-point remainder, see <span class="t-lc"><a href="../numeric/math/remainder.html" title="cpp/numeric/math/remainder">std::remainder</a></span> and <span class="t-lc"><a href="../numeric/math/fmod.html" title="cpp/numeric/math/fmod">std::fmod</a></span>.
</p><p>In <a href="overload_resolution.html#Call_to_an_overloaded_operator" title="cpp/language/overload resolution">overload resolution against user-defined operators</a>, for every pair of promoted arithmetic types <code>LA</code> and <code>RA</code> and for every pair of promoted integral types <code>LI</code> and <code>RI</code> the following function signatures participate in overload resolution:
</p>
<table class="t-dcl-begin"><tbody>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">LRA operator<span class="sy2">*</span><span class="br0">(</span>LA, RA<span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">LRA operator<span class="sy2">/</span><span class="br0">(</span>LA, RA<span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">LRI operator<span class="sy2">%</span><span class="br0">(</span>LI, RI<span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl-sep"><td></td><td></td><td></td></tr>
</tbody></table>
<p>where <code>LRx</code> is the result of usual arithmetic conversions on <code>Lx</code> and <code>Rx</code>.
</p>
<div class="t-example"><div class="t-example-live-link"><div class="coliru-btn coliru-btn-run-init">Run this code</div></div>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="co2">#include &lt;iostream&gt;</span>
 
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
    <span class="kw4">char</span> c <span class="sy1">=</span> <span class="nu0">2</span><span class="sy4">;</span>
    <span class="kw4">unsigned</span> <span class="kw4">int</span> un <span class="sy1">=</span> <span class="nu0">2</span><span class="sy4">;</span>
    <span class="kw4">int</span>  n <span class="sy1">=</span> <span class="sy2">-</span><span class="nu0">10</span><span class="sy4">;</span>
    <a href="../io/cout.html"><span class="kw1762">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span>  <span class="st0">"2 * (-10), where 2 is a char    = "</span> <span class="sy1">&lt;&lt;</span> c <span class="sy2">*</span> n <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span>
              <span class="sy1">&lt;&lt;</span>  <span class="st0">"2 * (-10), where 2 is unsigned  = "</span> <span class="sy1">&lt;&lt;</span> un <span class="sy2">*</span> n <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span>
              <span class="sy1">&lt;&lt;</span>  <span class="st0">"-10 / 2.12  = "</span> <span class="sy1">&lt;&lt;</span> n <span class="sy2">/</span> <span class="nu16">2.12</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span>
              <span class="sy1">&lt;&lt;</span>  <span class="st0">"-10 / 21  = "</span> <span class="sy1">&lt;&lt;</span> n <span class="sy2">/</span> <span class="nu0">21</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span>
              <span class="sy1">&lt;&lt;</span>  <span class="st0">"-10 % 21  = "</span> <span class="sy1">&lt;&lt;</span> n <span class="sy2">%</span> <span class="nu0">21</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span><span class="sy4">;</span>
<span class="br0">}</span></pre></div></div>
<p>Output:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="text source-text"><pre class="de1">2 * (-10), where 2 is a char    = -20
2 * (-10), where 2 is unsigned  = 4294967276
-10 / 2.12  = -4.71698
-10 / 21  = 0
-10 % 21  = -10</pre></div></div> 
</div>
<h4><span class="mw-headline" id="Bitwise_logic_operators">Bitwise logic operators</span></h4>
<p>The bitwise arithmetic operator expressions have the form 
</p>
<table class="t-sdsc-begin">

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <code><b>~</b></code> <span class="t-spar">rhs</span>
</td>
<td> (1)
</td>
<td class="t-sdsc-nopad">
</td></tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">lhs</span> <code><b>&amp;</b></code> <span class="t-spar">rhs</span>
</td>
<td> (2)
</td>
<td class="t-sdsc-nopad">
</td></tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">lhs</span> <code><b>|</b></code> <span class="t-spar">rhs</span>
</td>
<td> (3)
</td>
<td class="t-sdsc-nopad">
</td></tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">lhs</span> <code><b>^</b></code> <span class="t-spar">rhs</span>
</td>
<td> (4)
</td>
<td class="t-sdsc-nopad">
</td></tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr></table>
<div class="t-li1"><span class="t-li">1)</span> bitwise NOT</div>
<div class="t-li1"><span class="t-li">2)</span> bitwise AND</div>
<div class="t-li1"><span class="t-li">3)</span> bitwise OR</div>
<div class="t-li1"><span class="t-li">4)</span> bitwise XOR</div>
<div class="t-li1"><span class="t-li"></span> For the built-in operators, <span class="t-spar">lhs</span> and <span class="t-spar">rhs</span> must both have integral or unscoped enumeration type. Usual arithmetic conversions are performed on both operands and determine the type of the result.</div>
<p>The result of operator~ is the bitwise NOT (one's complement) value of the argument (after promotion). The result of operator&amp; is the bitwise AND value of the operands (after usual arithmetic conversions). The result of operator|is the bitwise OR value of the operands (after usual arithmetic conversions). The result of operator^ is the bitwise XOR value of the operands (after usual arithmetic conversions).
</p><p>There is an ambiguity in the grammar when <span class="t-c"><span class="mw-geshi cpp source-cpp">~</span></span> is followed by a <a href="type-id.html#type_naming" title="cpp/language/type">type name</a> <span class="t-rev-inl t-since-cxx11"><span>or <a href="decltype.html" title="cpp/language/decltype">decltype</a> specifier</span> <span><span class="t-mark-rev t-since-cxx11">(since C++11)</span></span></span>: it can either be operator~ or start a <a href="destructor.html" title="cpp/language/destructor">destructor</a> identifier). The ambiguity is resolved by treating <span class="t-c"><span class="mw-geshi cpp source-cpp">~</span></span> as operator~. <span class="t-c"><span class="mw-geshi cpp source-cpp">~</span></span> can start a destructor identifier only in places where forming an operator~ is syntatically invalid.
</p><p>In <a href="overload_resolution.html#Call_to_an_overloaded_operator" title="cpp/language/overload resolution">overload resolution against user-defined operators</a>, for every pair of promoted integral types <code>L</code> and <code>R</code> the following function signatures participate in overload resolution:
</p>
<table class="t-dcl-begin"><tbody>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">R operator~<span class="br0">(</span>R<span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">LR operator<span class="sy3">&amp;</span><span class="br0">(</span>L, R<span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">LR operator<span class="sy3">^</span><span class="br0">(</span>L, R<span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">LR operator<span class="sy3">|</span><span class="br0">(</span>L, R<span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl-sep"><td></td><td></td><td></td></tr>
</tbody></table>
<p>where <code>LR</code> is the result of usual arithmetic conversions on <code>L</code> and <code>R</code>.
</p>
<div class="t-example"><div class="t-example-live-link"><div class="coliru-btn coliru-btn-run-init">Run this code</div></div>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="co2">#include &lt;iostream&gt;</span>
<span class="co2">#include &lt;iomanip&gt;</span>
<span class="co2">#include &lt;bitset&gt;</span>
 
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
    uint16_t mask <span class="sy1">=</span> <span class="nu12">0x00f0</span><span class="sy4">;</span>
    uint32_t x0 <span class="sy1">=</span> <span class="nu12">0x12345678</span><span class="sy4">;</span>
    uint32_t x1 <span class="sy1">=</span> x0 <span class="sy3">|</span> mask<span class="sy4">;</span>
    uint32_t x2 <span class="sy1">=</span> x0 <span class="sy3">&amp;</span> ~mask<span class="sy4">;</span>
    uint32_t x3 <span class="sy1">=</span> x0 <span class="sy3">&amp;</span> mask<span class="sy4">;</span>
    uint32_t x4 <span class="sy1">=</span> x0 <span class="sy3">^</span> mask<span class="sy4">;</span>
    uint32_t x5 <span class="sy1">=</span> ~x0<span class="sy4">;</span>
    <span class="kw1">using</span> bin16 <span class="sy1">=</span> <a href="../utility/bitset.html"><span class="kw1032">std::<span class="me2">bitset</span></span></a><span class="sy1">&lt;</span><span class="nu0">16</span><span class="sy1">&gt;</span><span class="sy4">;</span>
    <span class="kw1">using</span> bin32 <span class="sy1">=</span> <a href="../utility/bitset.html"><span class="kw1032">std::<span class="me2">bitset</span></span></a><span class="sy1">&lt;</span><span class="nu0">32</span><span class="sy1">&gt;</span><span class="sy4">;</span>
    <a href="../io/cout.html"><span class="kw1762">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span> <a href="../io/manip/hex.html"><span class="kw1786">std::<span class="me2">hex</span></span></a> <span class="sy1">&lt;&lt;</span> <a href="../io/manip/showbase.html"><span class="kw1770">std::<span class="me2">showbase</span></span></a>
              <span class="sy1">&lt;&lt;</span> <span class="st0">"Mask: "</span> <span class="sy1">&lt;&lt;</span> mask <span class="sy1">&lt;&lt;</span> <a href="../io/manip/setw.html"><span class="kw1801">std::<span class="me2">setw</span></span></a><span class="br0">(</span><span class="nu0">49</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> bin16<span class="br0">(</span>mask<span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span>
              <span class="sy1">&lt;&lt;</span> <span class="st0">"Value: "</span> <span class="sy1">&lt;&lt;</span> x0 <span class="sy1">&lt;&lt;</span> <a href="../io/manip/setw.html"><span class="kw1801">std::<span class="me2">setw</span></span></a><span class="br0">(</span><span class="nu0">42</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> bin32<span class="br0">(</span>x0<span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span>
              <span class="sy1">&lt;&lt;</span> <span class="st0">"Setting bits: "</span> <span class="sy1">&lt;&lt;</span> x1 <span class="sy1">&lt;&lt;</span> <a href="../io/manip/setw.html"><span class="kw1801">std::<span class="me2">setw</span></span></a><span class="br0">(</span><span class="nu0">35</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> bin32<span class="br0">(</span>x1<span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span>
              <span class="sy1">&lt;&lt;</span> <span class="st0">"Clearing bits: "</span> <span class="sy1">&lt;&lt;</span> x2 <span class="sy1">&lt;&lt;</span> <a href="../io/manip/setw.html"><span class="kw1801">std::<span class="me2">setw</span></span></a><span class="br0">(</span><span class="nu0">34</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> bin32<span class="br0">(</span>x2<span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span>
              <span class="sy1">&lt;&lt;</span> <span class="st0">"Selecting bits: "</span> <span class="sy1">&lt;&lt;</span> x3 <span class="sy1">&lt;&lt;</span> <a href="../io/manip/setw.html"><span class="kw1801">std::<span class="me2">setw</span></span></a><span class="br0">(</span><span class="nu0">39</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> bin32<span class="br0">(</span>x3<span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span>
              <span class="sy1">&lt;&lt;</span> <span class="st0">"XOR-ing bits: "</span> <span class="sy1">&lt;&lt;</span> x4 <span class="sy1">&lt;&lt;</span> <a href="../io/manip/setw.html"><span class="kw1801">std::<span class="me2">setw</span></span></a><span class="br0">(</span><span class="nu0">35</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> bin32<span class="br0">(</span>x4<span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span>
              <span class="sy1">&lt;&lt;</span> <span class="st0">"Inverting bits: "</span> <span class="sy1">&lt;&lt;</span> x5 <span class="sy1">&lt;&lt;</span> <a href="../io/manip/setw.html"><span class="kw1801">std::<span class="me2">setw</span></span></a><span class="br0">(</span><span class="nu0">33</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> bin32<span class="br0">(</span>x5<span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span><span class="sy4">;</span>
<span class="br0">}</span></pre></div></div>
<p>Output:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="text source-text"><pre class="de1">Mask: 0xf0                                 0000000011110000
Value: 0x12345678          00010010001101000101011001111000
Setting bits: 0x123456f8   00010010001101000101011011111000
Clearing bits: 0x12345608  00010010001101000101011000001000
Selecting bits: 0x70       00000000000000000000000001110000
XOR-ing bits: 0x12345688   00010010001101000101011010001000
Inverting bits: 0xedcba987 11101101110010111010100110000111</pre></div></div> 
</div>
<h4><span class="mw-headline" id="Bitwise_shift_operators">Bitwise shift operators</span></h4>
<p>The bitwise shift operator expressions have the form 
</p>
<table class="t-sdsc-begin">

<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">lhs</span> <code><b>&lt;&lt;</b></code> <span class="t-spar">rhs</span>
</td>
<td> (1)
</td>
<td class="t-sdsc-nopad">
</td></tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr>
<tr class="t-sdsc">
<td> <span class="t-spar">lhs</span> <code><b>&gt;&gt;</b></code> <span class="t-spar">rhs</span>
</td>
<td> (2)
</td>
<td class="t-sdsc-nopad">
</td></tr>



<tr>
<td colspan="10" class="t-sdsc-sep">
</td></tr></table>
<div class="t-li1"><span class="t-li">1)</span> left shift of <span class="t-spar">lhs</span> by <span class="t-spar">rhs</span> bits</div>
<div class="t-li1"><span class="t-li">2)</span> right shift of <span class="t-spar">lhs</span> by <span class="t-spar">rhs</span> bits</div>
<div class="t-li1"><span class="t-li"></span> For the built-in operators, <span class="t-spar">lhs</span> and <span class="t-spar">rhs</span> must both have integral or unscoped enumeration type. Integral promotions are performed on both operands.</div>
<p>The return type is the type of the left operand after integral promotions. 
</p>
 <table class="t-rev-begin">
<tr class="t-rev t-until-cxx20"><td>
<p>For unsigned <span class="t-c"><span class="mw-geshi cpp source-cpp">a</span></span>, the value of <span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy1">&lt;&lt;</span> b</span></span> is the value of <span class="texhtml" style="white-space: nowrap;">a * 2<span class="t-su">b<br></span></span>, reduced modulo <span class="texhtml" style="white-space: nowrap;">2<span class="t-su">N<br></span></span> where N is the number of bits in the return type (that is, bitwise left shift is performed and the bits that get shifted out of the destination type are discarded). 
</p><p>For signed and non-negative <span class="t-c"><span class="mw-geshi cpp source-cpp">a</span></span>, if <span class="texhtml" style="white-space: nowrap;">a * 2<span class="t-su">b<br></span></span> is representable in the unsigned version of the return type, then that value, <a href="implicit_cast.html#Integral_conversions" title="cpp/language/implicit conversion">converted</a> to signed, is the value of <span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy1">&lt;&lt;</span> b</span></span> (this makes it legal to create <span class="t-lc"><a href="../types/climits.html" title="cpp/types/climits">INT_MIN</a></span> as <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="nu0">1</span> <span class="sy1">&lt;&lt;</span> <span class="nu0">31</span></span></span>); otherwise the behavior is undefined.
</p><p>For negative <span class="t-c"><span class="mw-geshi cpp source-cpp">a</span></span>, the behavior of <span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy1">&lt;&lt;</span> b</span></span> is undefined. 
</p><p>For unsigned <span class="t-c"><span class="mw-geshi cpp source-cpp">a</span></span> and for signed and non-negative <span class="t-c"><span class="mw-geshi cpp source-cpp">a</span></span>, the value of <span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy1">&gt;&gt;</span> b</span></span> is the integer part of <span class="texhtml" style="white-space: nowrap;">a/2<span class="t-su">b<br></span></span>.
</p><p>For negative <span class="t-c"><span class="mw-geshi cpp source-cpp">a</span></span>, the value of <span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy1">&gt;&gt;</span> b</span></span> is implementation-defined (in most implementations, this performs arithmetic right shift, so that the result remains negative).
</p>
</td>
<td><span class="t-mark-rev t-until-cxx20">(until C++20)</span></td></tr>
<tr class="t-rev t-since-cxx20"><td>
<p>The value of <span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy1">&lt;&lt;</span> b</span></span> is the unique value congruent to <span class="texhtml" style="white-space: nowrap;">a * 2<span class="t-su">b<br></span></span> modulo <span class="texhtml" style="white-space: nowrap;">2<span class="t-su">N<br></span></span> where N is the number of bits in the return type (that is, bitwise left shift is performed and the bits that get shifted out of the destination type are discarded).
</p><p>The value of <span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy1">&gt;&gt;</span> b</span></span> is <span class="texhtml" style="white-space: nowrap;">a/2<span class="t-su">b<br></span></span>, rounded down (in other words, right shift on signed <span class="t-c"><span class="mw-geshi cpp source-cpp">a</span></span> is arithmetic right shift).
</p>
</td>
<td><span class="t-mark-rev t-since-cxx20">(since C++20)</span></td></tr>
</table>
<p>In any case, if the value of the right operand is negative or is greater or equal to the number of bits in the promoted left operand, the behavior is undefined.
</p><p>In <a href="overload_resolution.html#Call_to_an_overloaded_operator" title="cpp/language/overload resolution">overload resolution against user-defined operators</a>, for every pair of promoted integral types <code>L</code> and <code>R</code>, the following function signatures participate in overload resolution:
</p>
<table class="t-dcl-begin"><tbody>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">L operator<span class="sy1">&lt;&lt;</span><span class="br0">(</span>L, R<span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr>
<tr class="t-dcl">
<td class="t-dcl-nopad"> <div><span class="mw-geshi cpp source-cpp">L operator<span class="sy1">&gt;&gt;</span><span class="br0">(</span>L, R<span class="br0">)</span></span></div></td>
<td class="t-dcl-nopad">  </td>
<td class="t-dcl-nopad">  </td>
</tr> 
<tr class="t-dcl-sep"><td></td><td></td><td></td></tr>
</tbody></table>
<div class="t-example"><div class="t-example-live-link"><div class="coliru-btn coliru-btn-run-init">Run this code</div></div>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="cpp source-cpp"><pre class="de1"><span class="co2">#include &lt;iostream&gt;</span>
 
<span class="kw2">enum</span> <span class="br0">{</span> ONE <span class="sy1">=</span> <span class="nu0">1</span>, TWO <span class="sy1">=</span> <span class="nu0">2</span> <span class="br0">}</span><span class="sy4">;</span>
 
<span class="kw4">int</span> main<span class="br0">(</span><span class="br0">)</span>
<span class="br0">{</span>
    <a href="../io/cout.html"><span class="kw1762">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span> <a href="../io/manip/hex.html"><span class="kw1786">std::<span class="me2">hex</span></span></a> <span class="sy1">&lt;&lt;</span> <a href="../io/manip/showbase.html"><span class="kw1770">std::<span class="me2">showbase</span></span></a><span class="sy4">;</span>
    <span class="kw4">char</span> c <span class="sy1">=</span> <span class="nu12">0x10</span><span class="sy4">;</span>
    <span class="kw4">unsigned</span> <span class="kw4">long</span> <span class="kw4">long</span> ull <span class="sy1">=</span> <span class="nu12">0x123</span><span class="sy4">;</span>
    <a href="../io/cout.html"><span class="kw1762">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span> <span class="st0">"0x123 &lt;&lt; 1 = "</span> <span class="sy1">&lt;&lt;</span> <span class="br0">(</span>ull <span class="sy1">&lt;&lt;</span> <span class="nu0">1</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span>
              <span class="sy1">&lt;&lt;</span> <span class="st0">"0x123 &lt;&lt; 63 = "</span> <span class="sy1">&lt;&lt;</span> <span class="br0">(</span>ull <span class="sy1">&lt;&lt;</span> <span class="nu0">63</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span> <span class="co1">// overflow in unsigned</span>
              <span class="sy1">&lt;&lt;</span> <span class="st0">"0x10 &lt;&lt; 10 = "</span> <span class="sy1">&lt;&lt;</span> <span class="br0">(</span>c <span class="sy1">&lt;&lt;</span> <span class="nu0">10</span><span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span><span class="sy4">;</span>   <span class="co1">// char is promoted to int</span>
    <span class="kw4">long</span> <span class="kw4">long</span> ll <span class="sy1">=</span> <span class="sy2">-</span><span class="nu0">1000</span><span class="sy4">;</span>
    <a href="../io/cout.html"><span class="kw1762">std::<span class="me2">cout</span></span></a> <span class="sy1">&lt;&lt;</span> <a href="../io/manip/hex.html"><span class="kw1785">std::<span class="me2">dec</span></span></a> <span class="sy1">&lt;&lt;</span> <span class="st0">"-1000 &gt;&gt; 1 = "</span> <span class="sy1">&lt;&lt;</span> <span class="br0">(</span>ll <span class="sy1">&gt;&gt;</span> ONE<span class="br0">)</span> <span class="sy1">&lt;&lt;</span> <span class="st0">'<span class="es1">\n</span>'</span><span class="sy4">;</span>
<span class="br0">}</span></pre></div></div>
<p>Output:
</p>
<div dir="ltr" class="mw-geshi" style="text-align: left;"><div class="text source-text"><pre class="de1">0x123 &lt;&lt; 1 = 0x246
0x123 &lt;&lt; 63 = 0x8000000000000000
0x10 &lt;&lt; 10 = 0x4000
-1000 &gt;&gt; 1 = -500</pre></div></div> 
</div>
<h3><span class="mw-headline" id="Standard_library">Standard library</span></h3>
<p>Arithmetic operators are overloaded for many standard library types.
</p>
<h4><span class="mw-headline" id="Unary_arithmetic_operators_2">Unary arithmetic operators</span></h4>
<table class="t-dsc-begin">

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../chrono/duration/operator_arith.html" title="cpp/chrono/duration/operator arith"> <span class="t-lines"><span>operator+</span><span>operator-</span></span></a></div></div>
</td>
<td>   implements unary + and unary - <br> <span class="t-mark">(public member function of <code>std::chrono::duration&lt;Rep,Period&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../numeric/complex/operator_arith2.html" title="cpp/numeric/complex/operator arith2"> <span class="t-lines"><span>operator+</span><span>operator-</span></span></a></div></div>
</td>
<td>   applies unary operators to complex numbers  <br> <span class="t-mark">(function template)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../numeric/valarray/operator_arith.html" title="cpp/numeric/valarray/operator arith"> <span class="t-lines"><span>operator+</span><span>operator-</span><span>operator~</span><span>operator!</span></span></a></div></div>
</td>
<td>   applies a unary arithmetic operator to each element of the valarray <br> <span class="t-mark">(public member function of <code>std::valarray&lt;T&gt;</code>)</span> </td></tr>
</table>
<h4><span class="mw-headline" id="Additive_operators_2">Additive operators</span></h4>
<table class="t-dsc-begin">

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../chrono/time_point/operator_arith2.html" title="cpp/chrono/time point/operator arith2"> <span class="t-lines"><span>operator+</span><span>operator-</span></span></a></div><div><span class="t-lines"><span><span class="t-mark-rev t-since-cxx11">(C++11)</span></span></span></div></div>
</td>
<td>   performs add and subtract operations involving a time point  <br> <span class="t-mark">(function template)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../chrono/duration/operator_arith4.html" title="cpp/chrono/duration/operator arith4"> <span class="t-lines"><span>operator+</span><span>operator-</span><span>operator*</span><span>operator/</span><span>operator%</span></span></a></div><div><span class="t-lines"><span><span class="t-mark-rev t-since-cxx11">(C++11)</span></span></span></div></div>
</td>
<td>   implements arithmetic operations with durations as arguments <br> <span class="t-mark">(function template)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../chrono/year_month_day/operator_arith_2.html" title="cpp/chrono/year month day/operator arith 2"> <span class="t-lines"><span>operator+</span><span>operator-</span></span></a></div><div><span class="t-lines"><span><span class="t-mark-rev t-since-cxx20">(C++20)</span></span></span></div></div>
</td>
<td>   adds or subtracts a <code>year_month_day</code> and some number of years or months  <br> <span class="t-mark">(function)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../string/basic_string/operator%2B.html" title="cpp/string/basic string/operator+"> <span class="t-lines"><span>operator+</span></span></a></div></div>
</td>
<td>   concatenates two strings or a string and a char  <br> <span class="t-mark">(function template)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/reverse_iterator/operator_arith.html" title="cpp/iterator/reverse iterator/operator arith"> <span class="t-lines"><span>operator+</span><span>operator-</span></span></a></div></div>
</td>
<td>  advances or decrements the iterator  <br> <span class="t-mark">(public member function of <code>std::reverse_iterator&lt;Iter&gt;</code>)</span>
</td></tr>


<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../iterator/move_iterator/operator_arith.html" title="cpp/iterator/move iterator/operator arith"> <span class="t-lines"><span>operator+</span><span>operator-</span></span></a></div></div>
</td>
<td>  advances or decrements the iterator  <br> <span class="t-mark">(public member function of <code>std::move_iterator&lt;Iter&gt;</code>)</span>
</td></tr>


<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../numeric/complex/operator_arith3.html" title="cpp/numeric/complex/operator arith3"> <span class="t-lines"><span>operator+</span><span>operator-</span><span>operator*</span><span>operator/</span></span></a></div></div>
</td>
<td>   performs complex number arithmetics on two complex values or a complex and a scalar <br> <span class="t-mark">(function template)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../numeric/valarray/operator_arith3.html" title="cpp/numeric/valarray/operator arith3"> <span class="t-lines"><span>operator+</span><span>operator-</span><span>operator*</span><span>operator/</span><span>operator%</span><span>operator&amp;</span><span>operator|</span><span>operator^</span><span>operator&lt;&lt;</span><span>operator&gt;&gt;</span><span>operator&amp;&amp;</span><span>operator||</span></span></a></div></div>
</td>
<td>   applies binary operators to each element of two valarrays, or a valarray and a value  <br> <span class="t-mark">(function template)</span> </td></tr>
</table>
<h4><span class="mw-headline" id="Multiplicative_operators_2">Multiplicative operators</span></h4>
<table class="t-dsc-begin">

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../chrono/duration/operator_arith4.html" title="cpp/chrono/duration/operator arith4"> <span class="t-lines"><span>operator+</span><span>operator-</span><span>operator*</span><span>operator/</span><span>operator%</span></span></a></div><div><span class="t-lines"><span><span class="t-mark-rev t-since-cxx11">(C++11)</span></span></span></div></div>
</td>
<td>   implements arithmetic operations with durations as arguments <br> <span class="t-mark">(function template)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../numeric/complex/operator_arith3.html" title="cpp/numeric/complex/operator arith3"> <span class="t-lines"><span>operator+</span><span>operator-</span><span>operator*</span><span>operator/</span></span></a></div></div>
</td>
<td>   performs complex number arithmetics on two complex values or a complex and a scalar <br> <span class="t-mark">(function template)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../numeric/valarray/operator_arith3.html" title="cpp/numeric/valarray/operator arith3"> <span class="t-lines"><span>operator+</span><span>operator-</span><span>operator*</span><span>operator/</span><span>operator%</span><span>operator&amp;</span><span>operator|</span><span>operator^</span><span>operator&lt;&lt;</span><span>operator&gt;&gt;</span><span>operator&amp;&amp;</span><span>operator||</span></span></a></div></div>
</td>
<td>   applies binary operators to each element of two valarrays, or a valarray and a value  <br> <span class="t-mark">(function template)</span> </td></tr>
</table>
<h4><span class="mw-headline" id="Bitwise_logic_operators_2">Bitwise logic operators</span></h4>
<table class="t-dsc-begin">

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../utility/bitset/operator_logic.html" title="cpp/utility/bitset/operator logic"> <span class="t-lines"><span>operator&amp;=</span><span>operator|=</span><span>operator^=</span><span>operator~</span></span></a></div></div>
</td>
<td>   performs binary AND, OR, XOR and NOT <br> <span class="t-mark">(public member function of <code>std::bitset&lt;N&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../utility/bitset/operator_logic2.html" title="cpp/utility/bitset/operator logic2"> <span class="t-lines"><span>operator&amp;</span><span>operator|</span><span>operator^</span></span></a></div></div>
</td>
<td>   performs binary logic operations on bitsets <br> <span class="t-mark">(function template)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../numeric/valarray/operator_arith.html" title="cpp/numeric/valarray/operator arith"> <span class="t-lines"><span>operator~</span></span></a></div></div>
</td>
<td>  applies a unary arithmetic operator to each element of the valarray <br> <span class="t-mark">(public member function of <code>std::valarray&lt;T&gt;</code>)</span>
</td></tr>


<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../numeric/valarray/operator_arith3.html" title="cpp/numeric/valarray/operator arith3"> <span class="t-lines"><span>operator^</span><span>operator&amp;</span><span>operator|</span></span></a></div></div>
</td>
<td>  applies binary operators to each element of two valarrays, or a valarray and a value  <br> <span class="t-mark">(function template)</span>
</td></tr>

</table>
<h4><span class="mw-headline" id="Bitwise_shift_operators_2">Bitwise shift operators</span></h4>
<table class="t-dsc-begin">

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../numeric/valarray/operator_arith3.html" title="cpp/numeric/valarray/operator arith3"> <span class="t-lines"><span>operator&lt;&lt;</span><span>operator&gt;&gt;</span></span></a></div></div>
</td>
<td>  applies binary operators to each element of two valarrays, or a valarray and a value  <br> <span class="t-mark">(function template)</span>
</td></tr>


<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../utility/bitset/operator_ltltgtgt.html" title="cpp/utility/bitset/operator ltltgtgt"> <span class="t-lines"><span>operator&lt;&lt;</span><span>operator&gt;&gt;</span></span></a></div></div>
</td>
<td>  performs binary shift left and shift right <br> <span class="t-mark">(public member function of <code>std::bitset&lt;N&gt;</code>)</span>
</td></tr>

</table>
<h4><span class="mw-headline" id="Stream_insertion.2Fextraction_operators">Stream insertion/extraction operators</span></h4>
<p>Throughout the standard library, bitwise shift operators are commonly overloaded with I/O stream (<span class="t-c"><span class="mw-geshi cpp source-cpp"><a href="../io/ios_base.html"><span class="kw1673">std::<span class="me2">ios_base</span></span></a><span class="sy3">&amp;</span></span></span> or one of the classes derived from it) as both the left operand and return type. Such operators are known as <i>stream insertion</i> and <i>stream extraction</i> operators:
</p>
<table class="t-dsc-begin">

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../io/basic_istream/operator_gtgt.html" title="cpp/io/basic istream/operator gtgt"> <span class="t-lines"><span>operator&gt;&gt;</span></span></a></div></div>
</td>
<td>   extracts formatted data <br> <span class="t-mark">(public member function of <code>std::basic_istream&lt;CharT,Traits&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../io/basic_istream/operator_gtgt2.html" title="cpp/io/basic istream/operator gtgt2"> <span class="t-lines"><span>operator&gt;&gt;<span class="t-dsc-small">(std::basic_istream)</span></span></span></a></div></div>
</td>
<td>   extracts characters and character arrays <br> <span class="t-mark">(function template)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../io/basic_ostream/operator_ltlt.html" title="cpp/io/basic ostream/operator ltlt"> <span class="t-lines"><span>operator&lt;&lt;</span></span></a></div></div>
</td>
<td>   inserts formatted data <br> <span class="t-mark">(public member function of <code>std::basic_ostream&lt;CharT,Traits&gt;</code>)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../io/basic_ostream/operator_ltlt2.html" title="cpp/io/basic ostream/operator ltlt2"> <span class="t-lines"><span>operator&lt;&lt;<span class="t-dsc-small">(std::basic_ostream)</span></span></span></a></div></div>
</td>
<td>   inserts character data or insert into rvalue stream <br> <span class="t-mark">(function template)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../numeric/complex/operator_ltltgtgt.html" title="cpp/numeric/complex/operator ltltgtgt"> <span class="t-lines"><span>operator&lt;&lt;</span><span>operator&gt;&gt;</span></span></a></div></div>
</td>
<td>   serializes and deserializes a complex number  <br> <span class="t-mark">(function template)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../utility/bitset/operator_ltltgtgt2.html" title="cpp/utility/bitset/operator ltltgtgt2"> <span class="t-lines"><span>operator&lt;&lt;</span><span>operator&gt;&gt;</span></span></a></div></div>
</td>
<td>   performs stream input and output of bitsets <br> <span class="t-mark">(function template)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../string/basic_string/operator_ltltgtgt.html" title="cpp/string/basic string/operator ltltgtgt"> <span class="t-lines"><span>operator&lt;&lt;</span><span>operator&gt;&gt;</span></span></a></div></div>
</td>
<td>   performs stream input and output on strings  <br> <span class="t-mark">(function template)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../numeric/random/linear_congruential_engine/operator_ltltgtgt.html" title="cpp/numeric/random/linear congruential engine/operator ltltgtgt"> <span class="t-lines"><span>operator&lt;&lt;</span><span>operator&gt;&gt;</span></span></a></div><div><span class="t-lines"><span><span class="t-mark-rev t-since-cxx11">(C++11)</span></span></span></div></div>
</td>
<td>   performs stream input and output on pseudo-random number engine  <br> <span class="t-mark">(function template)</span> </td></tr>

<tr class="t-dsc">
<td>  <div class="t-dsc-member-div"><div><a href="../numeric/random/uniform_int_distribution/operator_ltltgtgt.html" title="cpp/numeric/random/uniform int distribution/operator ltltgtgt"> <span class="t-lines"><span>operator&lt;&lt;</span><span>operator&gt;&gt;</span></span></a></div><div><span class="t-lines"><span><span class="t-mark-rev t-since-cxx11">(C++11)</span></span></span></div></div>
</td>
<td>   performs stream input and output on pseudo-random number distribution  <br> <span class="t-mark">(function template)</span> </td></tr>
</table>
<h3><span class="mw-headline" id="Defect_reports">Defect reports</span></h3>
<p>The following behavior-changing defect reports were applied retroactively to previously published C++ standards.
</p>
<table class="dsctable" style="font-size:0.8em">
<tr>
<th> DR
</th>
<th> Applied to
</th>
<th> Behavior as published
</th>
<th> Correct behavior
</th></tr>
<tr>
<td> <a rel="nofollow" class="external text" href="https://cplusplus.github.io/CWG/issues/614.html">CWG 614</a>
</td>
<td> C++98
</td>
<td> the algebraic quotient of integer division was<br>rounded in implementation-defined direction
</td>
<td> the algebraic quotient of integer<br>division is truncated towards zero<br>(fractional part is discarded)
</td></tr>
<tr>
<td> <a rel="nofollow" class="external text" href="https://cplusplus.github.io/CWG/issues/1450.html">CWG 1450</a>
</td>
<td> C++98
</td>
<td> the result of <span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy2">/</span> b</span></span> was unspecified if<br>it is not representable in the result type
</td>
<td> the behavior of both <span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy2">/</span> b</span></span> and<br><span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy2">%</span> b</span></span> is undefined in this case
</td></tr>
<tr>
<td> <a rel="nofollow" class="external text" href="https://cplusplus.github.io/CWG/issues/1457.html">CWG 1457</a>
</td>
<td> C++98
</td>
<td> the behavior of shifting the leftmost <code>1</code> bit of a<br>positive signed value into the sign bit was undefined
</td>
<td> made well-defined
</td></tr>
<tr>
<td> <a rel="nofollow" class="external text" href="https://cplusplus.github.io/CWG/issues/1504.html">CWG 1504</a>
</td>
<td> C++98
</td>
<td> a pointer to a base class subobject of an array<br>element could be used in pointer arithmetic
</td>
<td> the behavior is<br>undefined in this case
</td></tr>
<tr>
<td> <a rel="nofollow" class="external text" href="https://cplusplus.github.io/CWG/issues/1515.html">CWG 1515</a>
</td>
<td> C++98
</td>
<td> only unsigned integers which declared <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="kw4">unsigned</span></span></span> <br>should obey the laws of arithmetic <span class="texhtml" style="white-space: nowrap;">modulo 2<span class="t-su">n<br></span></span>
</td>
<td> applies to all unsigned integers
</td></tr>
<tr>
<td> <a rel="nofollow" class="external text" href="https://cplusplus.github.io/CWG/issues/1865.html">CWG 1865</a>
</td>
<td> C++98
</td>
<td> the resolution of <a rel="nofollow" class="external text" href="https://cplusplus.github.io/CWG/issues/1504.html">CWG issue 1504</a> made the behaviors<br>of pointer arithmetic involving pointers to array element<br>undefined if the pointed-to type and the array element<br>type have different cv-qualifications in non-top levels
</td>
<td> made well-defined
</td></tr>
<tr>
<td> <a rel="nofollow" class="external text" href="https://cplusplus.github.io/CWG/issues/1971.html">CWG 1971</a>
</td>
<td> C++98
</td>
<td> it was unclear whether the rule resolving the<br>ambiguity of <span class="t-c"><span class="mw-geshi cpp source-cpp">~</span></span> applies to cases such as <span class="t-c"><span class="mw-geshi cpp source-cpp">~X<span class="br0">(</span><span class="nu0">0</span><span class="br0">)</span></span></span>
</td>
<td> the rule applies to such cases
</td></tr>
<tr>
<td> <a rel="nofollow" class="external text" href="https://cplusplus.github.io/CWG/issues/2419.html">CWG 2419</a>
</td>
<td> C++98
</td>
<td> a pointer to non-array object was only treated as a<br>pointer to the first element of an array with size 1<br>in pointer arithmetic if the pointer is obtained by <span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy3">&amp;</span></span></span>
</td>
<td> applies to all pointers<br>to non-array objects
</td></tr></table>
<h3><span class="mw-headline" id="See_also">See also</span></h3>
<p><a href="operator_precedence.html" title="cpp/language/operator precedence">Operator precedence</a>
</p><p><a href="operators.html" title="cpp/language/operators">Operator overloading</a>
</p>
<table class="wikitable">

<tr style="text-align:center">
<th colspan="7"> Common operators
</th></tr>
<tr style="text-align:center">
<td> <a href="operator_assignment.html" title="cpp/language/operator assignment"> assignment</a>
</td>
<td> <a href="operator_incdec.html" title="cpp/language/operator incdec"> increment<br>decrement</a>
</td>
<td> <strong class="selflink"> arithmetic</strong>
</td>
<td> <a href="operator_logical.html" title="cpp/language/operator logical"> logical</a>
</td>
<td> <a href="operator_comparison.html" title="cpp/language/operator comparison"> comparison</a>
</td>
<td> <a href="operator_member_access.html" title="cpp/language/operator member access"> member<br>access</a>
</td>
<td> <a href="operator_other.html" title="cpp/language/operator other"> other</a>
</td></tr>
<tr style="text-align:center">
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy1">=</span> b<br>
a <span class="sy2">+</span><span class="sy1">=</span> b<br>
a <span class="sy2">-</span><span class="sy1">=</span> b<br>
a <span class="sy2">*</span><span class="sy1">=</span> b<br>
a <span class="sy2">/</span><span class="sy1">=</span> b<br>
a <span class="sy2">%</span><span class="sy1">=</span> b<br>
a <span class="sy3">&amp;</span><span class="sy1">=</span> b<br>
a <span class="sy3">|</span><span class="sy1">=</span> b<br>
a <span class="sy3">^</span><span class="sy1">=</span> b<br>
a <span class="sy1">&lt;&lt;=</span> b<br>
a <span class="sy1">&gt;&gt;=</span> b</span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy2">++</span>a<br>
<span class="sy2">--</span>a<br>
a<span class="sy2">++</span><br>
a<span class="sy2">--</span></span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy2">+</span>a<br>
<span class="sy2">-</span>a<br>
a <span class="sy2">+</span> b<br>
a <span class="sy2">-</span> b<br>
a <span class="sy2">*</span> b<br>
a <span class="sy2">/</span> b<br>
a <span class="sy2">%</span> b<br>
~a<br>
a <span class="sy3">&amp;</span> b<br>
a <span class="sy3">|</span> b<br>
a <span class="sy3">^</span> b<br>
a <span class="sy1">&lt;&lt;</span> b<br>
a <span class="sy1">&gt;&gt;</span> b</span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp"><span class="sy3">!</span>a<br>
a <span class="sy3">&amp;&amp;</span> b<br>
a <span class="sy3">||</span> b</span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp">a <span class="sy1">==</span> b<br>
a <span class="sy3">!</span><span class="sy1">=</span> b<br>
a <span class="sy1">&lt;</span> b<br>
a <span class="sy1">&gt;</span> b<br>
a <span class="sy1">&lt;=</span> b<br>
a <span class="sy1">&gt;=</span> b<br>
a <span class="sy1">&lt;=&gt;</span> b</span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp">a<span class="br0">[</span>b<span class="br0">]</span><br>
<span class="sy2">*</span>a<br>
<span class="sy3">&amp;</span>a<br>
a<span class="sy2">-</span><span class="sy1">&gt;</span>b<br>
a.<span class="me1">b</span><br>
a<span class="sy2">-</span><span class="sy1">&gt;</span><span class="sy2">*</span>b<br>
a.<span class="sy2">*</span>b</span></span>
</p>
</td>
<td>
<p><span class="t-c"><span class="mw-geshi cpp source-cpp">a<span class="br0">(</span>...<span class="br0">)</span><br>
a, b<br>
a <span class="sy4">?</span> b <span class="sy4">:</span> c</span></span>
</p>
</td></tr>
<tr>
<th colspan="7"> Special operators
</th></tr>
<tr>
<td colspan="7">
<p><a href="static_cast.html" title="cpp/language/static cast"><tt>static_cast</tt></a> converts one type to another related type <br>
<a href="dynamic_cast.html" title="cpp/language/dynamic cast"><tt>dynamic_cast</tt></a> converts within inheritance hierarchies <br>
<a href="const_cast.html" title="cpp/language/const cast"><tt>const_cast</tt></a> adds or removes <a href="cv.html" title="cpp/language/cv">cv</a> qualifiers<br>
<a href="reinterpret_cast.html" title="cpp/language/reinterpret cast"><tt>reinterpret_cast</tt></a> converts type to unrelated type<br>
<a href="explicit_cast.html" title="cpp/language/explicit cast">C-style cast</a> converts one type to another by a mix of <code>static_cast</code>, <code>const_cast</code>, and <code>reinterpret_cast</code> <br>
<a href="new.html" title="cpp/language/new"><tt>new</tt></a> creates objects with dynamic storage duration<br>
<a href="delete.html" title="cpp/language/delete"><tt>delete</tt></a> destructs objects previously created by the new expression and releases obtained memory area<br>
<a href="sizeof.html" title="cpp/language/sizeof"><tt>sizeof</tt></a> queries the size of a type<br>
<a href="sizeof....html" title="cpp/language/sizeof..."><tt>sizeof...</tt></a> queries the size of a <a href="parameter_pack.html" title="cpp/language/parameter pack">parameter pack</a> <span class="t-mark-rev t-since-cxx11">(since C++11)</span><br>
<a href="typeid.html" title="cpp/language/typeid"><tt>typeid</tt></a> queries the type information of a type<br>
<a href="noexcept.html" title="cpp/language/noexcept"><tt>noexcept</tt></a> checks if an expression can throw an exception <span class="t-mark-rev t-since-cxx11">(since C++11)</span><br>
<a href="alignof.html" title="cpp/language/alignof"><tt>alignof</tt></a> queries alignment requirements of a type <span class="t-mark-rev t-since-cxx11">(since C++11)</span>
</p>
</td></tr></table>
<table class="t-dsc-begin">

</table>

<!-- 
NewPP limit report
Preprocessor visited node count: 14608/1000000
Preprocessor generated node count: 21805/1000000
Post‐expand include size: 351179/2097152 bytes
Template argument size: 81195/2097152 bytes
Highest expansion depth: 32/40
Expensive parser function count: 0/100
-->

<!-- Saved in parser cache with key mwiki1-mwiki_en_:pcache:idhash:703-0!*!0!!en!*!* and timestamp 20220728031828 -->
</div>                    <!-- /bodycontent -->
                                        <!-- printfooter -->
                    <div class="printfooter">
                    Retrieved from "<a href="https://en.cppreference.com/mwiki/index.php?title=cpp/language/operator_arithmetic&amp;oldid=141460">https://en.cppreference.com/mwiki/index.php?title=cpp/language/operator_arithmetic&amp;oldid=141460</a>"                    </div>
                    <!-- /printfooter -->
                                                            <!-- catlinks -->
                    <!-- /catlinks -->
                                                            <div class="visualClear"></div>
                    <!-- debughtml -->
                                        <!-- /debughtml -->
                </div>
                <!-- /bodyContent -->
            </div>
        </div>
        <!-- /content -->
        <!-- footer -->
        <div id="cpp-footer-base" class="noprint">
            <div id="footer">
                        <div id="cpp-navigation">
            <h5>Navigation</h5>
            <ul><li><a href="https://en.cppreference.com/w/cpp/language/operator_arithmetic">Online version</a></li><li>Offline version retrieved 2022-07-30 14:05.</li></ul></div>
                        <ul id="footer-info">
                                    <li id="footer-info-lastmod"> This page was last modified on 27 July 2022, at 20:18.</li>
                                    <li id="footer-info-viewcount">This page has been accessed 533,567 times.</li>
                            </ul>
                    </div>
        </div>
        <!-- /footer -->
        <script>if(window.mw){
mw.loader.state({"site":"loading","user":"missing","user.groups":"ready"});
}</script>
<script src="../../../common/skin_scripts.js"></script>
<script>if(window.mw){
mw.loader.load(["mediawiki.action.view.postEdit","mediawiki.user","mediawiki.page.ready","mediawiki.searchSuggest","mediawiki.hidpi","ext.gadget.ColiruCompiler","ext.gadget.MathJax"], null, true);
}</script>
<script src="../../../common/site_scripts.js"></script>
<script type="text/javascript">
var _gaq = _gaq || [];
_gaq.push(['_setAccount', 'UA-2828341-1']);
_gaq.push(['_setDomainName', 'cppreference.com']);
_gaq.push(['_trackPageview']);
</script><!-- Served in 0.042 secs. -->
	</body>
<!-- Cached 20220728032508 -->
</html>